text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
long long int bg = pow(10, 9) + 7;
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long int power(long long int x, long long int y, long long int p) {
if (x == 0) return 0;
if (y == 0) return 1;
long long int s = y / 2;
long long int f = power(x, s, p) % p;
if (y % 2 == 0)
return (f * f) % p;
else
return (((f * f) % p) * x % p) % p;
}
void build1(long long int node, long long int seg[], long long int arr[],
long long int start, long long int end) {
if (start == end) {
seg[node] = arr[start];
return;
}
long long int mid = (start + end) / 2;
build1(2 * node, seg, arr, start, mid);
build1(2 * node + 1, seg, arr, mid + 1, end);
seg[node] = seg[2 * node] + seg[2 * node + 1];
}
long long int query1(long long int node, long long int seg[],
long long int arr[], long long int start,
long long int end, long long int l, long long int r) {
long long int mid = (start + end) / 2;
if (r < start || l > end)
return 0;
else if (l <= start && r >= end)
return seg[node];
else
return query1(2 * node, seg, arr, start, mid, l, r) +
query1(2 * node + 1, seg, arr, mid + 1, end, l, r);
}
long long int nc2(long long int x) { return (x * (x - 1)) / 2; }
int main() {
long long int n, p, k, i;
cin >> n >> p >> k;
map<long long int, long long int> boom;
long long int arr[n], sum = 0;
for (i = 0; i < n; i++) {
cin >> arr[i];
;
long long int a = power(arr[i], 4, p) % p, b = (k * arr[i]) % p;
long long int c = (a - b + p) % p;
if (boom.find(c) == boom.end())
boom[c] = 1;
else
boom[c]++;
}
for (auto it : boom) sum += nc2(it.second);
cout << sum;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300050;
int n;
long long p, k;
long long A[maxn];
unordered_map<long long, int> mp;
int main() {
scanf("%d%lld%lld", &n, &p, &k);
for (int i = 0; i < n; i++) {
scanf("%lld", &A[i]);
long long x = A[i] * (A[i] % p * A[i] % p * A[i] % p - k + p) % p;
mp[x]++;
}
long long ans = 0;
for (auto x : mp) {
ans += x.second * (x.second - 1) / 2;
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, p, k, ans;
map<int, int> mp;
int main() {
scanf("%d%d%d", &n, &p, &k);
while (n--) {
long long x;
scanf("%lld", &x);
ans += mp[(x * x % p * x % p * x % p - x * k % p + p) % p]++;
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using ll = long long;
int p;
std::map<int, int> count;
int mult(int a, int b) { return (ll)a * b % p; }
int sub(int a, int b) {
a -= b;
if (a < 0) {
a += p;
}
return a;
}
int main() {
int n, k;
scanf("%d%d%d", &n, &p, &k);
for (int i = 0; i < n; i++) {
int ai;
scanf("%d", &ai);
ai = sub(mult(k, ai), mult(mult(ai, ai), mult(ai, ai)));
count[ai]++;
}
long long answer = 0;
for (auto p : count) {
answer += (ll)p.second * (p.second - 1) / 2;
}
printf("%lld\n", answer);
return 0;
}
|
#include <bits/stdc++.h>
int dr[] = {2, 2, -2, -2, 1, -1, 1, -1};
int dc[] = {1, -1, 1, -1, 2, 2, -2, -2};
int dr1[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dc1[] = {1, -1, 1, 0, -1, 0, 1, -1};
int dr2[] = {0, 0, 1, -1};
int dc2[] = {1, -1, 0, 0};
using namespace std;
long long int a[300005];
int main() {
long long int n, p, k, i, j;
while (cin >> n >> p >> k) {
for (long long int i = 1; i < n + 1; i++) cin >> a[i];
map<long long int, long long int> mp;
long long int ans = 0;
for (i = 1; i <= n; i++) {
long long int r = (a[i] * a[i]) % p;
r = (r * r) % p;
long long int r1 = (k * a[i]) % p;
long long int r2 = (r - r1 + p) % p;
ans += mp[r2];
mp[r2]++;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int arr[333333], arr2[333333];
map<long long int, vector<int> > m;
map<long long int, int> vis;
int main(void) {
long long int n, p, k;
scanf("%lld%lld%lld", &n, &p, &k);
for (int e = 0; e < n; e++) scanf("%lld", &arr[e]);
for (int e = 0; e < n; e++) {
long long int now = arr[e];
for (int q = 0; q < 3; q++) now = (now * arr[e]) % p;
long long int kk = (k * arr[e]) % p;
arr2[e] = (now - kk + p) % p;
}
sort(arr2, arr2 + n);
long long int ans = 0;
long long int tot = 1;
for (int e = 1; e < n; e++) {
if (arr2[e] == arr2[e - 1]) {
tot++;
} else {
ans += ((tot * (tot - 1)) / 2);
tot = 1;
}
}
ans += ((tot * (tot - 1)) / 2);
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> M;
signed main() {
long long p, n, k;
cin >> n >> p >> k;
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long tmp;
cin >> tmp;
M[(tmp * tmp % p * tmp % p * tmp % p - k * tmp % p + p) % p]++;
}
for (map<long long, long long>::iterator it = M.begin(); it != M.end();
it++) {
long long x = it->second;
ans += (x * (x - 1)) / 2;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp;
long long n, p, k, x, ans;
long long mul(long long a, long long b) { return 1LL * a * b % p; }
template <typename Head, typename... Tail>
long long mul(Head H, Tail... T) {
return mul(H, mul(T...));
}
long long sum(long long a, long long b) { return (a + b + p) % p; }
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> p >> k;
while (n--) {
long long x;
cin >> x;
long long tmp = (1LL * x * x % p * x % p * x % p - 1LL * x * k % p + p) % p;
ans += mp[tmp]++;
}
return cout << ans, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod_pow(long long x, long long k, long long mod) {
long long ret = 1;
while (k) {
if (k & 1) ret *= x, ret %= mod;
x *= x, x %= mod;
k >>= 1;
}
return ret;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(12);
long long n, p, k;
cin >> n >> p >> k;
vector<long long> A(n);
long long ans = 0;
map<long long, long long> m;
for (int i = 0; i < n; ++i) {
cin >> A[i];
long long t = (A[i] * k % p - mod_pow(A[i], 4, p)) % p;
t += p;
t %= p;
ans += m[t];
++m[t];
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
const int N = 1e6 + 10, MOD = 1e9 + 7;
const long long INF = 1 << 30;
std::map<int, int> mp;
long long a[N];
long long cal(long long x, long long k, long long p) {
long long res = x * x % p;
res = res * res % p;
res = ((res - k * x) % p + p) % p;
return res;
}
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, p, k;
cin >> n >> p >> k;
long long ans = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
long long tmp = cal(a[i], k, p);
ans += mp[tmp];
mp[tmp]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300005;
int n;
long long K, P;
long long s[MAXN];
map<long long, long long> c;
int main() {
long long x, xx, ans = 0, cnt = 0;
;
scanf("%d%lld%lld", &n, &P, &K);
for (int i = 1; i <= n; i++) {
scanf("%lld", &x);
x %= P;
xx = x * x % P * x % P * x % P - K * x % P;
xx = (xx % P + P) % P;
if (!c.count(xx)) {
c[xx] = 0;
s[++cnt] = xx;
}
c[xx]++;
}
for (int i = 1; i <= cnt; i++) {
x = s[i];
ans += c[x] * (c[x] - 1) / 2;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, p, k, a[100001], x, ans;
map<long long, long long> mp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> p >> k;
for (int i = 1; i <= n; i++) {
cin >> x;
mp[(((x * x) % p * ((x * x) % p)) % p + p * p - k * x) % p]++;
}
for (auto it : mp) {
ans += it.second * (it.second - 1) / 2;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long p, k;
map<long long, int> mp;
long long ksm(long long a, long long k) {
long long res = 1;
while (k) {
if (k & 1) res = (res * a) % p;
a = (a * a) % p;
k >>= 1;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> p >> k;
for (int i = 1; i <= n; ++i) {
long long a;
cin >> a;
long long tmp = (ksm(a, 4) - k * a + p * p) % p;
mp[tmp]++;
}
long long ans = 0;
for (auto pli : mp) {
ans += 1ll * pli.second * (pli.second - 1) / 2;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solution() {
map<long long, long long> m;
long long ans = 0;
long long n, p, k;
cin >> n >> p >> k;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
long long r = x;
x = (x * x) % p;
x = (x * x) % p;
x -= (k * r) % p;
if (x < 0) {
x += p;
}
m[x]++;
}
for (auto x : m) {
ans += ((x.second - 1) * x.second) / 2;
}
cout << ans;
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long T = 1;
while (T--) {
solution();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 922337203685477110;
const long long N = 200000;
const long long M = 22;
long long mod;
long long binpow(long long a, long long b) {
a %= mod;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
long long mult(long long a, long long b) { return (a % mod * b % mod) % mod; }
long long add(long long a, long long b) {
a += b;
if (a >= mod) return a - mod;
return a;
}
long long sub(long long a, long long b) {
a -= b;
if (a < 0) return a + mod;
return a;
}
long long inverse(long long a) { return binpow(a, mod - 2); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, p, k;
cin >> n >> p >> k;
mod = p;
long long a[n + 3];
long long ans = 0;
map<long long, long long> m;
for (long long i = 0; i < n; i++) {
cin >> a[i];
long long r = sub(binpow(a[i], 4), mult(k, a[i]));
if (r >= 0)
m[r]++;
else
m[p + r]++;
}
for (auto it : m) {
long long k1 = it.second;
if (k1 > 1) {
ans += ((k1 * (k1 - 1)) / 2);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inff = 0x3f3f3f3f3f3f3f3f;
long long n, a[300008], k, p, ans;
map<long long, long long> mp;
long long as(long long x) {
return ((x * x % p * x % p * x % p) - (k * x % p) + p) % p;
}
int main() {
cin.tie(0);
cout.tie(0);
cin >> n >> p >> k;
for (int i(1); i <= (n); ++i) scanf("%lld", &a[i]), ans += mp[as(a[i])]++;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int PRIME = 1e9 + 7;
const int INF = 2e9;
const long long INFLL = 4e18;
const int MAX_N = 1e4 + 6;
long long ans = 0;
int n, m;
long long k, p;
unordered_map<int, int> mp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> p >> k;
long long x, ia;
unordered_map<int, int>::iterator it;
for (int i = (int)(0); i < (int)(n); ++i) {
cin >> ia;
x = (ia * ia) % p;
x = (x * x) % p;
x -= (k * ia) % p;
if (x < 0) x += p;
it = mp.find((int)x);
if (it == mp.end()) {
mp.insert(make_pair((int)x, 1));
} else {
ans += it->second;
it->second++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, p, k;
cin >> n >> p >> k;
map<long long int, long long int> count;
long long int ans = 0;
long long int t;
for (int i = 0; i < n; i++) {
cin >> t;
t = ((t * k) - (((t * t) % p) * ((t * t) % p) % p) + p) % p;
count[t]++;
}
for (auto i = count.begin(); i != count.end(); i++) {
ans += (i->second) * (i->second - 1);
}
cout << ans / 2 << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const int INF2 = 0x3f3f3f3f;
const long long INF64 = 0x3f3f3f3f3f3f3f3f;
const double PI = 3.14159265358979323846;
const long long MOD = 1e9 + 7;
const long long TARGET = (1LL << 32) - 1LL;
template <typename T>
T Max(T val1, T val2) {
return val1 > val2 ? val1 : val2;
}
template <typename T, typename... Args>
T Max(T val, Args... arg) {
T result = Max(arg...);
return Max(val, result);
}
template <typename T>
inline T read() {
T X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return w ? -X : X;
}
const int MAXN = 505;
int n, m, k;
int w, h;
int CASE = 1;
char str[MAXN];
int dp[MAXN];
int dp2[MAXN];
int cmp(int s1, int e1, int s2, int e2) {
if (!e2) return 1;
while (str[s1] == '0') {
s1++;
}
while (str[s2] == '0') {
s2++;
}
if (e1 - s1 > e2 - s2)
return 1;
else if (e1 - s1 < e2 - s2)
return -1;
for (int i = 0; i <= e1 - s1; i++) {
if (str[s1 + i] < str[s2 + i])
return -1;
else if (str[s1 + i] > str[s2 + i])
return 1;
}
return 0;
}
int p;
inline long long cal(long long x) {
long long r = x;
for (int i = 0; i < 3; i++) {
r = (r * x) % p;
}
r -= (x * (long long)k) % p;
r += p;
return r % p;
}
int main() {
map<long long, int> _map;
scanf("%d %d %d", &n, &p, &k);
for (int i = 0; i < n; i++) {
_map[cal(read<int>())]++;
}
long long ans = 0;
for (auto a : _map) {
ans += (long long)a.second * (long long)(a.second - 1) / 2;
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcount(s);
}
template <class T>
inline T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long n, a[300005], k, p, res;
map<long long, long long> m;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> p >> k;
long long mod = p;
for (long long i = 1, _b = n; i <= _b; i++) cin >> a[i];
for (long long i = 1, _b = n; i <= _b; i++) {
long long tmp =
(a[i] * a[i] % mod * a[i] % mod * a[i] % mod - k * a[i] % mod + mod) %
mod;
res += m[tmp];
m[tmp]++;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod;
int sum(int a, int b) {
int s = a + b;
if (s >= mod) s -= mod;
return s;
}
int sub(int a, int b) {
int s = a - b;
if (s < 0) s += mod;
return s;
}
int mult(int a, int b) { return (1LL * a * b) % mod; }
int pw4(int x) { return mult(mult(x, x), mult(x, x)); }
int n, p, k;
map<int, int> mp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> mod >> k;
long long ans = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
int val = sub(pw4(x), mult(k, x));
ans += mp[val];
mp[val]++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f;
const long long MAXN = 3e5 + 5;
long long n, MOD, k, ans;
map<long long, long long> mp;
signed main() {
scanf("%lld%lld%lld", &n, &MOD, &k);
for (long long i = 1; i <= n; i++) {
long long x;
scanf("%lld", &x);
x = (x * x % MOD * x % MOD * x % MOD + MOD - x * k % MOD) % MOD;
mp[x]++;
}
for (map<long long, long long>::iterator it = mp.begin(); it != mp.end();
it++) {
long long x = it->second;
ans += (x - 1) * x / 2;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e6 + 7, M = 1000000007, inf = INT_MAX;
const long long INF = LLONG_MAX;
int pwrmod(int a, int b, int mod) {
int res = 1;
a %= mod;
while (b) {
if (b & 1) res = (1LL * res * a) % mod;
a = (1LL * a * a) % mod;
b >>= 1;
}
return res;
}
void solve() {
int n, p, k;
cin >> n >> p >> k;
unordered_map<int, int> mp;
int ans = 0;
for (int i = 0; i < (int)n; i++) {
int x;
cin >> x;
int val = pwrmod(x, 4, p);
val -= (1LL * k * x) % p;
if (val < 0) val += p;
ans += mp[val];
mp[val]++;
}
cout << ans << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int test = 1;
while (test--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int a[N];
long long n, p, k;
map<long long, long long> mp;
long long get(long long num) { return num * num % p * num % p * num % p; }
int main() {
cin >> n >> p >> k;
long long ans = 0, t;
for (int i = 1; i <= n; ++i) {
cin >> t;
t = (get(t) - k * t % p + p) % p;
ans += mp[t];
mp[t]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int p, n, k, vs;
cin >> n >> p >> k;
unordered_map<int, int> vals;
for (int i = 0; i < n; i++) {
cin >> vs;
int t = ((long long)(vs) * (vs) % p);
t = ((long long)(t) * (t) % p);
int tar = t + p - ((long long)(k) * (vs) % p);
tar %= p;
if (vals.find(tar) == vals.end()) {
vals[tar] = 0;
}
vals[tar]++;
}
int c = 0;
for (auto keyVal : vals) {
c += keyVal.second * (keyVal.second - 1) / 2;
}
cout << c << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int maxN = 103000;
long long n, k, p;
long long f(long long x, long long y) {
x = x % p;
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
res = res % p;
return res;
}
void solve() {
cin >> n >> p >> k;
long long a[n];
map<long long, long long> mp;
long long cnt = 0;
for (int i = 0; i < (n); ++i) cin >> a[i];
for (int i = 0; i < (n); ++i) {
long long res = (p + f(a[i], 4) - ((k % p) * (a[i] % p)) % p) % p;
mp[res]++;
}
for (auto& i : mp) cnt += (i.second * (i.second - 1) / 2);
cout << cnt << endl;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, p, k, sum;
map<int, int> mp;
int main(void) {
scanf("%lld %lld %lld", &n, &p, &k);
for (long long i = 0, x; i < n; i++) {
scanf("%lld", &x);
long long t = x * x % p;
t = t * t % p;
t = (t - k * x) % p;
t = (t + p) % p;
mp[t]++;
}
for (auto e : mp) {
long long x = e.second;
sum += x * (x - 1) / 2;
}
printf("%lld\n", sum);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
long long A[N], n, p, k, ans;
vector<long long> resp;
long long fexp(long long x, long long y) {
if (y == 0)
return 1;
else if (y % 2 == 0)
return fexp((x * x) % p, y / 2) % p;
else
return (x * fexp((x * x) % p, y / 2)) % p;
}
int main() {
cin >> n >> p >> k;
for (int i = 1; i <= n; i++) {
cin >> A[i];
A[i] = (fexp(A[i], 4) - (k * A[i]) % p + p) % p;
}
sort(A + 1, A + n + 1);
int cont = 1;
for (int i = 1; i <= n; i++) {
if (A[i] == A[i + 1] && i < n)
cont++;
else
resp.push_back(cont), cont = 1;
}
for (int i = 0; i < resp.size(); i++)
if (resp[i] != 1) ans += (resp[i] * (resp[i] - 1)) / 2;
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p;
int sum(int a, int b) { return (a + b) % p; }
int sub(int a, int b) { return (a - b < 0) ? a - b + p : a - b; }
int mult(int a, int b) { return (1LL * a * b) % p; }
int power4(int x) { return mult(mult(x, x), mult(x, x)); }
int main() {
map<int, int> mp;
int n;
int k;
cin >> n >> p >> k;
long long ans = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
int val = sub(power4(x), mult(k, x));
ans += mp[val]++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 6031)
#pragma warning(disable : 4101)
using namespace std;
const int INF = 1e9;
const long long LINF = 1e18;
const double PI = acos(-1);
const int MAXN = 300005;
int n, p, k, A[MAXN];
long long ans;
map<int, int> B;
int get_mod_val(int a) {
long long ca = (long long)a;
ca = (((((ca * ca) % p) * ((ca * ca) % p)) % p) - (long long)k * ca +
p * (long long)p) %
p;
assert(ca >= 0);
return ca;
}
int main() {
scanf("%d%d%d", &n, &p, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &A[i]);
ans += B[get_mod_val(A[i])]++;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int MOD = (int)1e9 + 7;
const int N = (int)3e5 + 7;
int n, p, k, a[N];
map<int, int> cnt;
inline int add(int a, int b) { return (a += b) >= p ? a - p : a; }
inline int mul(int a, int b) { return 1ll * a * b % p; }
void Init() {
cnt.clear();
for (int i = (1); i < (n + 1); ++i) scanf("%d", a + i);
}
int Solve() {
long long ans = 0;
for (int i = (1); i < (n + 1); ++i) {
int tmp = mul(mul(a[i], a[i]), mul(a[i], a[i]));
tmp = add(tmp, p - mul(k, a[i]));
ans += cnt[tmp];
cnt[tmp]++;
}
return printf("%lld\n", ans);
}
int main() {
while (~scanf("%d%d%d", &n, &p, &k)) {
Init();
Solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int mod;
int sum(int a, int b) {
int s = a + b;
if (s >= mod) s -= mod;
return s;
}
int sub(int a, int b) {
int s = a - b;
if (s < 0) s += mod;
return s;
}
int mult(int a, int b) { return (1LL * a * b) % mod; }
int pw4(int x) { return mult(mult(x, x), mult(x, x)); }
int n, p, k;
map<int, int> mp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> mod >> k;
long long ans = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
int val = sub(pw4(x), mult(k, x));
ans += mp[val];
mp[val]++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> ve[100005];
long long vis[100005], z;
void solve() {
vector<long long> v;
vector<pair<long long, long long>> vp;
map<long long, long long> mp;
set<long long> st;
multiset<long long> mst;
long long n = 0, m = 0, i = 0, j = 0, k = 0, c = 0, l = 0, r = 0, p = 0,
q = 0, x = 0, y = 0, z = 0, flag = 0, sum = 0;
long long a[300005] = {0}, b[300005] = {0}, ans[300005];
string s, t;
cin >> n >> p >> k;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) {
x = p + (((((a[i] * a[i]) % p) * a[i]) % p) * a[i]) % p - (k * a[i]) % p;
x %= p;
mp[x]++;
}
for (auto it = mp.begin(); it != mp.end(); ++it) {
y = it->second;
z += (y * (y - 1)) / 2;
}
cout << z << '\n';
}
bool imp = false;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
if (imp) cin >> t;
long long j = t;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long int p;
long long int powmod(long long int base, long long int exp) {
long long int answer = 1;
while (exp) {
if (exp & 1) {
answer *= base;
answer %= p;
}
base *= base;
base %= p;
exp /= 2;
}
return answer;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int n, k;
cin >> n >> p >> k;
long long int answer = 0;
std::map<long long int, long long int> mp;
while (n--) {
long long int temp;
cin >> temp;
long long int b1 = (powmod(temp, 4) - (k * temp) % p + p) % p;
mp[b1]++;
}
for (auto itr : mp) {
answer += (itr.second) * (itr.second - 1);
}
answer /= 2;
cout << answer;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> M;
int main() {
long long n, p, k;
cin >> n >> p >> k;
long long ans = 0;
for (int m = 0; m < n; m++) {
long long j;
cin >> j;
long long t =
(((1ll * j * j) % p * j % p * j % p - 1ll * k * j % p) + p) % p;
ans += M[t];
M[t]++;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 300010;
const long long INF = 0x3f3f3f3f;
const long long MOD = 1e9 + 7;
long long n, p, k, ans, cur, x;
vector<long long> a(N);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> p >> k;
for (int i = 0; i < n; ++i) {
cin >> x;
a[i] = x;
for (int j = 0; j < 2; ++j) x = (x * x) % p;
a[i] = (x - k * a[i]) % p;
if (a[i] < 0) a[i] += p;
}
unordered_map<long long, long long> m;
for (int i = 0; i < n; ++i) {
m[a[i]]++;
}
for (auto x : m) {
cur = x.second;
ans += (cur * (cur - 1)) / 2;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first - a.second) > (b.first - b.second);
}
long long int power(long long int x, long long int y) {
long long int temp;
if (y == 0) return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else
return x * temp * temp;
}
long long int power_mod(long long int b, long long int e, long long int m) {
long long int a = 1;
while (e != 0) {
if ((e & 1) == 1) a = (a * b) % m;
b = (b * b) % m;
e >>= 1;
}
return a % m;
}
map<long long int, long long int> cnt;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, p, k;
cin >> n >> p >> k;
set<int> s;
long long int ans = 0;
for (int i = 0; i < n; ++i) {
long long int a;
cin >> a;
long long int tp = power_mod(a, 4, p) - (k * a) % p;
if (tp < 0) tp += p;
s.insert(tp);
cnt[tp]++;
}
for (int i : s) {
ans += (cnt[i] * (cnt[i] - 1)) / 2;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000007;
const int MOD = 1000000007;
const int nmax = 301234;
int n, p, k;
long long a[nmax], tmp, res, cnt;
int main() {
scanf("%d%d%d", &n, &p, &k);
for (int i = 0; i < n; ++i) {
scanf("%I64d", &a[i]);
tmp = a[i] * a[i] % p;
tmp = tmp * tmp % p;
a[i] = (tmp - k * a[i]) % p;
if (a[i] < 0) a[i] += p;
}
sort(a, a + n);
cnt = 1;
for (int i = 1; i < n; ++i) {
if (a[i] != a[i - 1]) {
res += cnt * (cnt - 1) / 2;
cnt = 1;
} else
++cnt;
}
res += cnt * (cnt - 1) / 2;
printf("%I64d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod;
long long fun(long long a, long long b) {
if (a == 0) {
return 0;
}
if (b == 0) {
return 1;
}
long long x = fun(a, b / 2);
x *= x;
x %= mod;
if (x < 0) {
x += mod;
}
if ((b & 1)) {
x = (a * x) % mod;
if (x < 0) {
x += mod;
}
return x;
}
return x;
}
int main() {
long long n, p, k;
cin >> n >> p >> k;
unordered_map<long long, long long> m;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
mod = p;
long long val = fun(a, 4);
val -= k * a;
val %= mod;
if (val < 0) {
val += mod;
}
m[val]++;
}
long long ans = 0;
for (auto i : m) {
ans += ((i.second * (i.second - 1)) / 2);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, p, k;
long long ans = 0;
map<int, int> s;
int main() {
scanf("%d %d %d", &n, &p, &k);
for (int i = 1, x; i <= n; ++i) {
scanf("%d", &x);
int a = (1LL * x * x) % p;
a = (1LL * a * a) % p;
a = ((0LL + a - 1LL * x * k) % p + p) % p;
ans += s[a];
s[a]++;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
void solution() {
map<long long, long long> m;
long long ans = 0;
long long n, p, k;
cin >> n >> p >> k;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
long long r = x;
x = (x * x) % p;
x = (x * x) % p;
x -= (k * r) % p;
if (x < 0) {
x += p;
}
ans += m[x];
m[x]++;
}
cout << ans;
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long T = 1;
while (T--) {
solution();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e6 + 7, M = 1000000007, inf = INT_MAX;
const long long INF = LLONG_MAX;
long long pwrmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
while (b) {
if (b & 1) res = (1LL * res * a) % mod;
a = (1LL * a * a) % mod;
b >>= 1;
}
return res;
}
void solve() {
long long n, p, k;
cin >> n >> p >> k;
long long arr[n];
unordered_map<long long, long long> mp;
long long ans = 0;
for (long long i = 0; i < (long long)n; i++) {
long long x;
cin >> x;
long long val = pwrmod(x, 4, p);
val -= (k * x) % p;
if (val < 0) val += p;
ans += mp[val];
mp[val]++;
}
cout << ans << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long test = 1;
while (test--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
long long expo(long long base, long long exponent, long long mod) {
long long ans = 1;
while (exponent != 0) {
if ((exponent & 1) == 1) {
ans = ans * base;
ans = ans % mod;
}
base = base * base;
base %= mod;
exponent >>= 1;
}
return ans % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long n, p, k;
cin >> n >> p >> k;
map<long long, long long> lol;
for (long long int i = 0; i < n; i++) {
long long x;
cin >> x;
long long temp = (expo(x, 4, p) - (k * x) % p + p) % p;
lol[temp]++;
}
long long ans = 0;
for (auto u : lol) ans += (u.second * (u.second - 1) / 2);
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos(-1.0);
const long double eps = 1e-6;
const int mod = 20180718;
const int maxn = 200 + 10;
const int M = 2e6 + 10;
const int N = 1e5 + 10;
const long long mm = (1LL << 32);
map<long long, long long> mp;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, p, k, res = 0;
cin >> n >> p >> k;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
res += mp[(x % p * x % p * x % p * x % p - k % p * x % p + p) % p]++;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp;
long long n, p, k, x, ans;
long long mul(long long a, long long b) { return 1LL * a * b % p; }
template <typename Head, typename... Tail>
long long mul(Head H, Tail... T) {
return mul(H, mul(T...));
}
long long sum(long long a, long long b) { return (a + b + p) % p; }
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> p >> k;
while (n--) {
long long x;
cin >> x;
ans += mp[sum(mul(x, x, x, x), -mul(x, k))]++;
}
return cout << ans, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int a[maxn], tmp[maxn];
map<long long, int> mp;
map<long long, int>::iterator it;
struct edge {
long long e, v;
long long ans;
};
bool cmp(struct edge a, struct edge b) {
if (a.e * b.v > a.v * b.e)
return true;
else
return false;
}
long long mulit(long long base, long long k, long long mod) {
long long ans = 1;
while (k) {
if (k % 2) ans = base * ans % mod;
base = base * base % mod;
k >>= 1;
}
return ans % mod;
}
long long sub(long long a, long long b, long long mod) {
long long ans = a - b;
if (ans < 0) ans += mod;
return ans;
}
int main() {
std::ios::sync_with_stdio(false);
int n, p, k;
memset(a, 0, sizeof(a));
cin >> n >> p >> k;
long long ans = 0;
for (int i = 0; i < n; ++i) {
long long x;
cin >> x;
long long val = sub(mulit(x, 4, p), ((k % p) * (x % p) % p), p);
ans += mp[val];
++mp[val];
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, p, k;
cin >> n >> p >> k;
vector<long long> v(n + 1);
unordered_map<long long, long long> m;
for (int i = 0; i < n; i++) {
cin >> v[i];
v[i] = (((((v[i] * v[i]) % p) * ((v[i] * v[i]) % p)) % p - (k * v[i]) % p) +
p) %
p;
m[v[i]]++;
}
long long ans = 0;
for (auto it = m.begin(); it != m.end(); it++) {
long long x = it->second;
ans += (x * (x - 1)) / 2;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300007;
long long n, p, k;
long long a[maxn], ans[maxn];
bool fg[maxn];
long long mult(long long a, long long b) { return (a * b) % p; }
int main() {
memset(fg, 0, sizeof(fg));
scanf("%lld%lld%lld", &n, &p, &k);
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
}
sort(a + 1, a + 1 + n);
int i = 1;
while (i <= n) {
int u = a[i], j = i;
while (j < n && a[j] == a[j + 1]) {
j++;
}
if (mult(mult(4 * a[j], a[j]), a[j]) != k) {
for (int k = i; k < j; ++k) {
fg[k] = 1;
}
}
i = j + 1;
}
int j = 0;
for (int i = 1; i <= n; ++i) {
if (!fg[i]) {
ans[++j] =
((mult(mult(a[i], a[i]), mult(a[i], a[i])) - mult(k, a[i])) % p + p) %
p;
}
}
long long ret = 0;
sort(ans + 1, ans + 1 + j);
i = 1;
while (i <= j) {
int u = ans[i], k = i;
while (k < j && ans[k] == ans[k + 1]) {
k++;
}
ret += (k - i + 1) * (k - i) / 2;
k++;
i = k;
}
printf("%lld\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, p, k, x, z, r;
map<long long, int> m;
int main() {
scanf("%lld%lld%lld", &n, &p, &k);
while (n--) {
scanf("%lld", &x);
z = x * x % p;
x = (z * z % p - k * x % p + p) % p;
r += m[x]++;
}
printf("%lld", r);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5 + 10;
long long raw[maxn];
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, k, p;
cin >> n >> p >> k;
map<long long, long long> cnt;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
long long xx = x * x % p;
raw[i] = ((xx * xx) % p - (k * x) % p + 2 * p) % p;
cnt[raw[i]]++;
}
long long ans = 0;
for (auto it : cnt) {
long long u = it.second;
ans += u * (u - 1) / 2;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, p, k;
cin >> n >> p >> k;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
long long b[n];
for (int i = 0; i < n; i++)
b[i] = ((((((a[i] * a[i]) % p) * a[i]) % p) * a[i]) % p);
map<long long, int> m;
for (int i = 0; i < n; i++) m[(b[i] - k * a[i] + k * p) % p]++;
long long res = 0;
for (auto x : m) {
res += (x.second) * (x.second - 1) / 2;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
long long a[1000003];
map<long long, int> mp;
int main() {
int n = read();
long long p = read(), k = read();
for (int i = 1; i <= n; i++)
a[i] = read(), ++mp[(a[i] * a[i] % p * a[i] % p + p - k) * a[i] % p];
long long ans = 0;
for (auto x : mp) ans += 1LL * x.second * (x.second - 1);
printf("%lld\n", ans / 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[300005];
unordered_map<int, int> mp;
unordered_map<int, int>::iterator p;
int main(void) {
int i, n, x, mod, res, ans = 0;
scanf("%d%d%d", &n, &mod, &res);
for (i = 1; i <= n; ++i) {
scanf("%d", &x);
++mp[((((long long)x * x % mod) * ((long long)x * x % mod) % mod -
(long long)res * x % mod) %
mod +
mod) %
mod];
}
for (p = mp.begin(); p != mp.end(); ++p) {
x = p->second;
ans = (ans + ((long long)x * (x - 1) / 2 % mod)) % mod;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
long long p, k;
cin >> n >> p >> k;
map<long long, long long> mpp;
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long u;
cin >> u;
u %= p;
long long u4 = (((u * u) % p * u) % p * u) % p;
u4 = (u4 - (u * k) % p + p) % p;
ans += mpp[u4];
mpp[u4] += 1;
}
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int i, n, p, k, x, val;
long long res;
map<int, int> m;
map<int, int>::iterator iter;
int sum(int a, int b) { return (a + b) % p; }
int sub(int a, int b) { return (a - b + p) % p; }
int mult(int a, int b) { return (1LL * a * b) % p; }
int pw4(int x) { return mult(mult(x, x), mult(x, x)); }
int main(void) {
cin >> n >> p >> k;
for (i = 0; i < n; i++) {
cin >> x;
val = sub(pw4(x), mult(k, x));
m[val]++;
}
for (iter = m.begin(); iter != m.end(); iter++) {
x = iter->second;
res += x * (x - 1) / 2;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> M;
signed main() {
long long p, n, k;
cin >> n >> p >> k;
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long tmp;
cin >> tmp;
ans += M[(tmp * tmp % p * tmp % p * tmp % p - k * tmp % p + p) % p];
M[(tmp * tmp % p * tmp % p * tmp % p - k * tmp % p + p) % p]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long mod1 = 998244353;
const double pie = 3.1415926535;
unsigned long long power(unsigned long long x, unsigned long long y) {
if (y == 0)
return 1;
else {
if (y % 2 == 0)
return power(x * x, y / 2);
else
return x * power(x * x, (y - 1) / 2);
}
}
long long mod_power(long long x, long long y, long long m) {
long long r = 1;
x = x % m;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) r = (r * x) % m;
y = y / 2;
x = (x * x) % m;
}
return r;
}
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int TESTS = 1;
while (TESTS--) {
long long n, p, k;
cin >> n >> p >> k;
vector<long long> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
map<long long, long long> M;
long long ans = 0;
for (int i = 0; i < n; i++) {
long long x = mod_power(v[i], 4, p);
long long y = x - (k * v[i]) % p;
y = (y + p) % p;
ans += M[y];
M[y]++;
}
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, i, k, p, q, a[300005], b[300005], ans, t;
unordered_map<long long, long long> mp;
unordered_map<long long, long long>::iterator it;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> p >> k;
for (i = 1; i <= n; i++) {
cin >> a[i];
b[i] = (a[i] * a[i] % p * a[i] % p * a[i] % p - a[i] * k % p + p) % p;
;
mp[b[i]]++;
}
for (it = mp.begin(); it != mp.end(); it++)
ans += (it->second * (it->second - 1)) / 2;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> a;
int main() {
long long n, p, k, ans = 0;
cin >> n >> p >> k;
long long x;
for (int i = 1; i <= n; i++) {
cin >> x;
long long tmp1 = x * x % p * x % p * x % p;
long long tmp2 = k * x % p;
long long res = (tmp1 - tmp2 + p) % p;
if (a.count(res) == false)
a[res]++;
else {
ans = ans + a[res];
a[res]++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = INT_MAX >> 1;
inline long long read() {
long long res(0), f(1);
register char c;
while (isspace(c = getchar()))
;
c == '-' ? f = -1, c = getchar() : 0;
while (res = (res << 1) + (res << 3) + (c & 15), isdigit(c = getchar()))
;
return res * f;
}
long long n, p, k;
long long a[300000 + 5];
long long f[300000 + 5];
map<long long, long long> mp;
inline void Ot() {
n = read(), p = read(), k = read();
for (register long long i = 1; i <= n; i++) a[i] = read();
for (register long long i = 1; i <= n; i++) {
f[i] = (a[i] * a[i]) % p * a[i] % p * a[i] % p - a[i] * k % p;
f[i] %= p;
if (f[i] < 0) f[i] += p;
}
long long ans = 0;
for (register long long i = 1; i <= n; i++) {
ans += mp[f[i]];
++mp[f[i]];
}
cout << ans << endl;
return;
}
signed main() { return Ot(), 0; }
|
#include <bits/stdc++.h>
using namespace std;
const long long pt = 239017;
const long long mod = 1e9 + 7;
const long long mod2 = 1e9 + 13;
const long long MAXN = 5e6 + 10;
long long n, p, k;
long long trbl(long long x, long long y) {
long long rs = x;
for (long long i = 2; i <= y; ++i) {
rs *= x;
rs %= p;
}
return rs;
}
map<long long, long long> ct;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n >> p >> k;
vector<long long> v(n);
for (long long i = 0; i < n; ++i) {
cin >> v[i];
v[i] = (trbl(v[i], 4) - (k * v[i]) % p + p) % p;
++ct[v[i]];
}
long long fita = 0;
for (auto el : ct) fita += (el.second * (el.second - 1)) / 2;
cout << fita;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nsz = 3e5;
int n;
long long k, mod, a[nsz + 5], b[nsz + 5], ans;
map<long long, int> mp;
long long inline qpow(long long a, int p) {
long long res = 1;
for (; p; p >>= 1) {
if (p & 1) {
res *= a;
res %= mod;
}
a *= a;
a %= mod;
}
return res % mod;
}
long long inline modify(long long a) {
a %= mod;
return a < 0 ? a + mod : a;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> mod >> k;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
++mp[modify(qpow(a[i], 4) - k * a[i] % mod)];
}
for (__typeof(mp.begin()) it = mp.begin(); it != mp.end(); ++it) {
ans += it->second * (it->second - 1) / 2;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) is >> v;
return is;
}
const int MOD = 1000000007;
const int N = 100005;
long long int M;
long long int power(long long int x, long long int n) {
long long int res = 1;
for (long long int i = 1; i <= n; i++) res = (res * x) % M;
return res;
}
void solve() {
long long int n, k;
cin >> n >> M >> k;
map<long long int, long long int> mp;
long long int ans = 0;
for (int i = 0; i < n; i++) {
long long int x;
cin >> x;
long long int nw = power(x, (long long int)4);
nw = (nw - (k * x) % M + M) % M;
if (mp.find(nw) != mp.end()) {
ans += mp[nw];
}
mp[nw]++;
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long int t = 1;
for (long int tt = 1; tt <= t; tt++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p;
long long fourthPow(long long num) {
int ans = 1;
for (int i = 0; i < 4; i++) {
ans = (ans * num) % p;
}
return ans;
}
int main() {
long long n, k;
cin >> n >> p >> k;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
map<long long, long long> Map;
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long val = (fourthPow(a[i]) - k * a[i]) % p;
if (val < 0) val += p;
if (Map.count(val) == 0)
Map[val] = 1;
else {
ans += Map[val];
Map[val]++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long int power(unsigned long long int a, unsigned long long int b,
unsigned long long int p) {
unsigned long long int res = 1;
a = a % p;
while (b > 0) {
if (b & 1) {
res = (res * a) % p;
b--;
}
a = (a * a) % p;
b >>= 1;
}
return res;
}
unsigned long long int gcd(unsigned long long int a, unsigned long long int b) {
return (b == 0) ? a : gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
unsigned long long int n, p, k;
cin >> n >> p >> k;
vector<unsigned long long int> v(n);
for (auto &i : v) cin >> i;
map<unsigned long long int, unsigned long long int> cnt;
for (unsigned long long int i = 0; i < n; i++) {
unsigned long long int cur = (power(v[i], 4, p) - (k * v[i]) % p + p) % p;
cnt[cur]++;
}
unsigned long long int ans = 0;
for (auto i : cnt) ans += (i.second * (i.second - 1)) / 2;
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int a[301010];
int main() {
int n, p, k;
scanf("%d%d%d", &n, &p, &k);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
int t = ((long long)(x) * (x) % p);
t = ((long long)(t) * (t) % p);
a[i] = t - ((long long)(k) * (x) % p);
if (a[i] < 0) a[i] += p;
}
sort(a, a + n);
long long ans = 0;
for (int i = 0, j = 0; i < n; i = j) {
while (j < n && a[i] == a[j]) j++;
int D = j - i;
ans += 1LL * D * (D - 1) / 2;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = int(1e9) + 7;
const long long int MOD64 = (long long int)(1e18) + 7;
const int INF = 0x7fffffff;
const long long int INF64 = 0x7fffffffffffffff;
const int N = 3e5 + 10;
long long int a[N];
long long int b[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, p, k;
cin >> n >> p >> k;
for (int i = int(0); i < int(n); i++) {
cin >> a[i];
long long int temp = a[i];
temp = temp * temp % p;
temp = temp * temp % p;
temp = (temp - k * a[i]) % p;
temp = (temp + p) % p;
b[i] = temp;
}
sort(b, b + n);
long long int ans = 0;
long long int cnt = b[0];
long long int num = 1;
for (int i = int(1); i < int(n); i++) {
while (b[i] == cnt && i < n) {
i++;
num++;
}
ans += (num - 1) * num / 2;
cnt = b[i];
num = 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int arr[300010];
int len, mod, k;
map<long long int, int> mp;
long long int combN2(long long int n) { return 1ll * n * (n - 1) / 2; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> len >> mod >> k;
for (int i = 0; i < len; i++) cin >> arr[i];
for (int i = 0; i < len; i++)
arr[i] = arr[i] * (arr[i] * arr[i] % mod * arr[i] % mod - k + mod) % mod;
sort(arr + 0, arr + len);
for (int i = 0; i < len; i++) mp[arr[i]]++;
long long int ans = 0;
for (auto p : mp)
if (p.second > 1) ans += combN2(p.second);
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 500005;
const long long inf = 0x3f3f3f3f3f3f3f3f;
const long long MOD = 100000007;
const double eps = 1e-10;
long long qpow(long long a, long long b) {
long long tmp = a % MOD, ans = 1;
while (b) {
if (b & 1) {
ans *= tmp, ans %= MOD;
}
tmp *= tmp, tmp %= MOD, b >>= 1;
}
return ans;
}
long long lowbit(long long x) { return x & -x; }
long long max(long long a, long long b) { return a > b ? a : b; }
long long min(long long a, long long b) { return a < b ? a : b; }
long long mmax(long long a, long long b, long long c) {
return max(a, max(b, c));
}
long long mmin(long long a, long long b, long long c) {
return min(a, min(b, c));
}
void mod(long long &a) {
a += MOD;
a %= MOD;
}
bool chk(long long cost) {}
long long half(long long l, long long r) {
while (l <= r) {
long long m = (l + r) / 2;
if (chk(m))
r = m - 1;
else
l = m + 1;
}
return l;
}
long long ll(long long p) { return p << 1; }
long long rr(long long p) { return p << 1 | 1; }
long long mm(long long l, long long r) { return (l + r) / 2; }
long long lg(long long x) { return (long long)log2(x) + 1; }
bool smleql(double a, double b) {
if (a < b || fabs(a - b) <= eps) return true;
return false;
}
double len(double a, double b, double c, double d) {
return sqrt((a - c) * (a - c) + (b - d) * (b - d));
}
bool isp(long long x) {
if (x == 1) return false;
if (x == 2) return true;
for (long long i = 2; i * i <= x; ++i)
if (x % i == 0) return false;
return true;
}
long long n, p, k, a[maxn];
long long ans = 0;
map<long long, long long> mp;
long long cal(long long x) {
return (((x * x) % p * ((x * x) % p)) % p - k * x % p + p) % p;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n >> p >> k;
for (long long i = 1; i <= n; ++i) {
cin >> a[i];
ans += mp[cal(a[i])];
mp[cal(a[i])]++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, p, k;
cin >> n >> p >> k;
long long int a[n];
long long int i;
map<long long int, long long int> mp;
for (i = 0; i < n; i++) {
cin >> a[i];
long long int sq = (a[i] * a[i]) % p;
sq = (sq * sq) % p;
long long int tmp = (a[i] * k) % p;
tmp = (sq - tmp + p) % p;
mp[tmp]++;
}
long long int ans = 0;
for (auto it = mp.begin(); it != mp.end(); it++) {
long long int c = it->second;
long long int tmp = (c * (c - 1)) / 2;
ans += tmp;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> Fr;
long long A[(int)(3e5 + 4)], n, p, k, ans, x;
int main() {
cin >> n >> p >> k;
for (int i = 0; i < n; ++i) {
cin >> A[i];
A[i] %= p;
x = (A[i] * A[i]) % p;
x = (x * x) % p;
A[i] = (x + p - (k * A[i]) % p) % p;
ans += Fr[A[i]];
++Fr[A[i]];
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, p, k;
cin >> n >> p >> k;
ll ans = 0;
map<ll, int> cnt;
for (int i = 0; i < n; i++) {
ll x;
cin >> x;
ll t = (x * x % p * x % p * x % p - k * x % p + p) % p;
ans += cnt[t];
cnt[t]++;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 100;
int n, p, k;
int main(int argc, const char* argv[]) {
while (~scanf("%d %d %d", &n, &p, &k)) {
map<int, int> mp;
long long ans = 0;
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
int y = (x * 1ll * ((x * 1ll * ((x * 1ll * x) % p)) % p - k)) % p;
y = (y + p) % p;
ans += mp[y];
mp[y] += 1;
}
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, arr[300004], p, k, ans;
map<long long int, long long int> mp;
int main() {
cin >> n >> p >> k;
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
long long int u = (arr[i] % p * arr[i] % p * arr[i] % p * arr[i] % p) % p;
long long int v = (k * arr[i]) % p;
long long int eff = (u - v + p) % p;
ans += mp[eff];
mp[eff]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 5;
int n;
int a[maxn];
int f[maxn];
int read() {
int x;
scanf("%d", &x);
return x;
}
int lowbit(int x) { return x & -x; }
int insert(int x, int y) {
if (f[x | y] > 1) return 0;
f[x | y]++;
for (int nx = x, ny = 0; nx; nx ^= lowbit(nx)) {
insert(nx ^ lowbit(nx), ny | y);
ny |= lowbit(nx);
}
return 0;
}
int main() {
int i, j;
n = read();
for (i = 0; i < n; i++) {
a[n - i] = read();
}
int ans = 0;
for (i = 1; i <= n; i++) {
int ret = 0;
for (j = 20; j >= 0; j--) {
if ((a[i] >> j) & 1) continue;
if (f[ret | (1 << j)] > 1) ret |= (1 << j);
}
if (i > 2) ans = max(ans, a[i] | ret);
insert(a[i], 0);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 21);
pair<int, int> rig[N];
int n, ar[N];
bool check(int val) {
vector<int> mask;
int i, j;
for (i = N - 1; i >= 0; i--) {
rig[i].first = 0;
rig[i].second = 0;
if ((val & i) == i) {
mask.push_back(i);
}
}
for (i = n; i >= 1; i--) {
j = (ar[i] & val);
if (!rig[j].first) {
rig[j].first = i;
} else {
if (!rig[j].second) {
rig[j].second = i;
}
}
}
for (i = 0; i < mask.size(); i++) {
for (j = 0; j < 21; j++) {
if (!(mask[i] & (1 << j))) {
continue;
}
if (rig[mask[i] ^ (1 << j)].first <= rig[mask[i]].second) {
rig[mask[i] ^ (1 << j)] = rig[mask[i]];
} else {
if (rig[mask[i] ^ (1 << j)].first < rig[mask[i]].first) {
rig[mask[i] ^ (1 << j)].second =
max(rig[mask[i] ^ (1 << j)].first, rig[mask[i]].second);
rig[mask[i] ^ (1 << j)].first = rig[mask[i]].first;
} else {
if (max(rig[mask[i] ^ (1 << j)].second, rig[mask[i]].first) <
rig[mask[i] ^ (1 << j)].first) {
rig[mask[i] ^ (1 << j)].second =
max(rig[mask[i] ^ (1 << j)].second, rig[mask[i]].first);
}
}
}
}
}
for (i = 1; i <= n; i++) {
j = (ar[i] & val);
if (rig[val ^ j].second > i) {
return true;
}
}
return false;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int i, j, k, l, now = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> ar[i];
}
for (i = 20; i >= 0; i--) {
if (check(now | (1 << i))) {
now |= (1 << i);
}
}
cout << now;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[5000010], a[1000010];
void dfs(int v, int k) {
if (k < 0) return;
if (f[v] >= 2) return;
dfs(v, k - 1);
if (v & (1 << k)) {
dfs(v ^ (1 << k), k - 1);
f[v ^ (1 << k)]++;
}
}
int main() {
int n, ans = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
dfs(a[n], 21);
f[a[n]]++;
dfs(a[n - 1], 21);
f[a[n - 1]]++;
for (int i = n - 2; i; --i) {
int res = 0;
for (int j = 1 << 21; j; j >>= 1)
if ((a[i] & j) == 0) {
if (f[res | j] >= 2) res |= j;
}
ans = max(ans, a[i] | res);
dfs(a[i], 21);
f[a[i]]++;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int N = 5e6 + 5;
const int M = 22;
int a[N];
int cnt[N];
int used[N];
int t;
void add(int mask) {
if (cnt[mask] > 1 || used[mask] == t) {
return;
}
cnt[mask]++;
used[mask] = t;
for (int i = 0; i < M; i++) {
if (mask & (1 << i)) {
add(mask ^ (1 << i));
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
int mask = 0;
t = i;
for (int j = M - 1; j >= 0; j--) {
if ((a[i] >> j) & 1) {
continue;
}
if (cnt[mask | (1 << j)] > 1) {
mask |= 1 << j;
}
}
if (i + 2 < n) {
ans = max(ans, a[i] | mask);
}
add(a[i]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct TopTwo {
int highest, second;
TopTwo() : highest(-1), second(-1) {}
void add(int pos) {
if (pos > highest) {
swap(highest, second);
highest = pos;
} else {
second = max(second, pos);
}
}
void add(const TopTwo& t) {
add(t.highest);
add(t.second);
}
};
int easy_solution(int n, vector<int>& xs) {
int k = 21;
vector<TopTwo> places(1 << k);
for (int i = 0; i < n; ++i) {
places[xs[i]].add(i);
}
for (int j = 0; j < k; ++j) {
for (int i = 0; i < (1 << k); ++i) {
if ((1 << j) & i) {
places[i - (1 << j)].add(places[i]);
}
}
}
int best = 0;
for (int j = k - 1; j >= 0; --j) {
int tmp = best + (1 << j);
bool possible = false;
for (int i = 0; i < n; ++i) {
int search_for = (~xs[i]) & tmp;
if (places[search_for].second > i) {
possible = true;
}
}
if (possible) {
best += (1 << j);
}
}
return best;
}
int main() {
int n;
cin >> n;
vector<int> xs(n);
for (int i = 0; i < n; ++i) {
cin >> xs[i];
}
cout << easy_solution(n, xs) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void desperate_optimization(int precision) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.setf(ios::showpoint);
cout.precision(precision);
}
const int N = 21;
const int MAXN = (1 << N);
int occ[MAXN + 5];
int arr[MAXN + 5];
void add(int u, int k) {
if (occ[u] >= 2) return;
occ[u]++;
for (int i = k; i >= 0; i--) {
if (u & (1 << i)) add(u ^ (1 << i), i);
}
}
void hora(int tc) {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
int res = 0;
for (int i = n - 1; i >= 0; i--) {
int tot = 0;
for (int j = N; j >= 0; j--) {
if (!(arr[i] & (1 << j))) {
if (occ[tot | (1 << j)] >= 2) {
tot |= (1 << j);
}
}
}
if (i <= n - 3) res = max(res, tot | arr[i]);
add(arr[i], N);
}
cout << res << '\n';
}
int main() {
desperate_optimization(10);
int ntc = 1;
for (int tc = 1; tc <= ntc; tc++) hora(tc);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
inline void gmx(int &x, int y) {
if (x < y) x = y;
}
inline void gmn(int &x, int y) {
if (x > y) x = y;
}
inline int read() {
char c = getchar();
int z = 0, f = 1;
while (c != '-' && (c > '9' || c < '0')) c = getchar();
if (c == '-') f = -1, c = getchar();
while (c >= '0' && c <= '9') z = (z << 1) + (z << 3) + c - '0', c = getchar();
return z * f;
}
const int N = 1 << 22;
pair<int, int> f[N];
int n, a[N], R, ans, tmp;
inline void ins(pair<int, int> &x, int k) {
k > x.first ? x.second = x.first, x.first = k : x.second = max(x.second, k);
}
inline int check(int x, int pos) { return f[x].second > pos; }
int main() {
n = read();
R = (1 << 21) - 1;
for (register int i = 1; i <= n; i++) ins(f[a[i] = read()], i);
for (register int j = 0; j <= 20; j++)
for (register int i = 0; i <= R; i++)
if (!(i & (1 << j)))
ins(f[i], f[i ^ (1 << j)].first), ins(f[i], f[i ^ (1 << j)].second);
for (register int i = 1, j; i < n - 1; gmx(ans, tmp | a[i]), i++)
for (tmp = 0, j = 20; ~j; j--)
if (!(a[i] & (1 << j))) tmp += check(tmp + (1 << j), i) * (1 << j);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
i >> p.first >> p.second;
return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
o << p.first << ' ' << p.second;
return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
if (t.empty()) o << '\n';
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
unsigned int logceil(long long first) {
return first ? 8 * sizeof(long long) - __builtin_clzll(first) : 0;
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U>& p) const {
return t(p.first) ^ (u(p.second) << 7);
}
};
} // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
l = m + 1;
r = m;
} else {
h = m - 1;
}
}
return r;
}
template <typename F>
double bshd(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
l = m;
} else {
h = m;
}
}
return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
h = m - 1;
r = m;
} else {
l = m + 1;
}
}
return r;
}
template <typename F>
double bsld(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
h = m;
} else {
l = m;
}
}
return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
public:
vector2() {}
vector2(size_t a, size_t b, T t = T())
: vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
public:
vector3() {}
vector3(size_t a, size_t b, size_t c, T t = T())
: vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
public:
vector4() {}
vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
: vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
public:
vector5() {}
vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
: vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
constexpr int L = 21;
constexpr int M = 1 << L;
class FBitsAndPieces {
public:
void solve(istream& cin, ostream& cout) {
int N;
cin >> N;
vector<int> A(N);
cin >> A;
vector<int> B(M, 0);
int best = 0;
for (int i = N - 1; i >= 0; --i) {
if (i + 3 <= N) {
int a = A[i], b = 0;
for (int j = L - 1; j >= 0; --j) {
if (a & 1 << j) continue;
b |= 1 << j;
if (B[b] < 2) b ^= 1 << j;
}
best = max(best, a | b);
}
B[A[i]]++;
vector<int> P{A[i]};
for (int j = 0; j < L; ++j) {
if (A[i] & 1 << j) {
int Q = P.size();
for (int k = 0; k < Q; ++k) {
int w = P[k] ^ 1 << j;
if (B[w] < 2) {
B[w]++;
P.push_back(w);
}
}
}
}
}
cout << best << endl;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
FBitsAndPieces solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void FLASH() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
void SETF() { cout.ios_base::setf(ios_base::fixed); }
void UNSETF() { cout.ios_base::unsetf(ios_base::fixed); }
int ar[2000001], az[2000001], fmv[2000001], smv[2000001], ST[2000001][21];
long long arr[2000001];
class sparse {
public:
void build(int n);
int query(int qs, int qd);
};
void sparse::build(int n) {
for (int i = 1; i <= n; i++) ST[i][0] = az[i];
for (int j = 1; (1 << j) <= n; j++) {
for (int i = 1; i <= n; i++) {
if (i + (1 << (j - 1)) <= n)
ST[i][j] = std::max(ST[i][j - 1], ST[i + (1 << (j - 1))][j - 1]);
}
}
return;
}
int sparse::query(int qs, int qd) {
int lx = 0;
for (lx = 0; (1 << lx) <= (qd - qs + 1); lx++)
;
lx--;
int mx = std::max(ST[qs][lx], ST[qd - (1 << lx) + 1][lx]);
return mx;
}
void solve(int T) {
memset(fmv, -1, sizeof(fmv));
memset(smv, -1, sizeof(smv));
int n;
std::cin >> n;
for (int i = 1; i <= n; i++) {
std::cin >> az[i];
ar[az[i]]++;
if (i > fmv[az[i]]) {
smv[az[i]] = fmv[az[i]];
fmv[az[i]] = i;
} else if ((i <= fmv[az[i]]) && (i > smv[az[i]]))
smv[az[i]] = i;
}
sparse Z;
Z.build(n);
for (int i = 0; i < 21; i++) {
for (int mask = 2000001 - 1; mask >= 0; mask--) {
if (mask & (1 << i)) {
ar[mask ^ (1 << i)] += ar[mask];
int m1 = 0, m2 = 0;
if (fmv[mask] > fmv[mask ^ (1 << i)]) {
m1 = fmv[mask];
m2 = max(smv[mask], fmv[mask ^ (1 << i)]);
} else if (fmv[mask] < fmv[mask ^ (1 << i)]) {
m1 = fmv[mask ^ (1 << i)];
m2 = max(smv[mask ^ (1 << i)], fmv[mask]);
} else {
m1 = fmv[mask];
m2 = max(smv[mask], smv[mask ^ (1 << i)]);
}
fmv[mask ^ (1 << i)] = m1;
smv[mask ^ (1 << i)] = m2;
}
}
}
int vx = 0;
for (int i = 1; i <= n; i++) {
int w = 0;
if ((ar[w] >= 2) && (smv[w] > i)) vx = std::max(vx, az[i]);
for (int j = 21 - 1; j >= 0; j--) {
if (!(az[i] & (1 << j))) {
if ((ar[w | (1 << j)] >= 2) && (smv[w | (1 << j)] > i)) {
vx = std::max(vx, az[i] | (w | (1 << j)));
w |= (1 << j);
}
}
}
}
std::cout << vx << "\n";
return;
}
int main(void) {
FLASH();
int T;
T = 1;
while (T--) solve(T);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000001, fullVal = (1 << 22) - 1;
pair<int, int> f[1 << 22];
int A[maxn];
inline void add(pair<int, int>& des, pair<int, int> org) {
if (org.first == des.first || org.first == des.second) {
org.first = 0;
}
if (org.second == des.first || org.second == des.second) {
org.second = 0;
swap(org.first, org.second);
}
if (org.first > des.second) {
des = org;
return;
}
if (des.second < org.second) {
des.first = des.second;
des.second = org.second;
} else if (des.first < org.second) {
des.first = org.second;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
for (int i = 1; i <= N; ++i) {
cin >> A[i];
add(f[A[i]], make_pair(0, i));
}
for (int i = fullVal; i; --i) {
for (int j = 1; j <= 22; ++j) {
if ((1 << ((j)-1)) & i) add(f[i ^ (1 << ((j)-1))], f[i]);
}
assert(f[i].first <= f[i].second);
}
int ans = 0;
for (int i = 1; i <= N - 2; ++i) {
int s = 0;
for (int j = 22; j; --j) {
if (((1 << ((j)-1)) & A[i]) == 0 && f[s | (1 << ((j)-1))].first > i)
s |= (1 << ((j)-1));
}
ans = max(ans, (A[i] | s));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vvpii = vector<vpii>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using vpdd = vector<pdd>;
using vvpdd = vector<vpdd>;
template <typename T>
void ckmin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = 0; i < (SZ); i++) re(a[i]);
}
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
if (pretty) pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
prContain<T, false>(x);
pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::iterator find(vector<T>& v, const T& x) {
auto it = lower_bound((v).begin(), (v).end(), x);
return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(vector<T>& v, const T& x) {
auto it = find(v, x);
assert(it != v.end() && *it == x);
return it - v.begin();
}
template <typename C, typename T>
vector<T> prefixes(const C& v, T zero) {
vector<T> res(int((v).size()) + 1, zero);
for (int i = 0; i < (int((v).size())); i++) res[i + 1] = res[i] + v[i];
return res;
}
template <typename C, typename T>
vector<T> suffixes(const C& v, T zero) {
vector<T> res(int((v).size()) + 1, zero);
for (int i = (int((v).size())) - 1; i >= 0; i--) res[i] = v[i] + res[i + 1];
return res;
}
} // namespace __algorithm
using namespace __algorithm;
struct monostate {
friend istream& operator>>(istream& is,
const __attribute__((unused)) monostate& ms) {
return is;
}
friend ostream& operator<<(ostream& os,
const __attribute__((unused)) monostate& ms) {
return os;
}
} ms;
template <typename W = monostate>
struct wedge {
int u, v, i;
W w;
wedge<W>(int _u = -1, int _v = -1, int _i = -1) : u(_u), v(_v), i(_i) {}
int operator[](int loc) const { return u ^ v ^ loc; }
friend void re(wedge& e) {
re(e.u, e.v, e.w);
--e.u, --e.v;
}
friend void pr(const wedge& e) { pr(e.u, "<-", e.w, "->", e.v); }
};
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(15);
if (int((second).size())) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace __io
using namespace __io;
int main() {
setIO();
int N;
re(N);
vi a(N);
re(a);
const int MAXV = 2e6 + 1, MAXB = 21;
vi ct(MAXV), lgen(MAXV, -1);
int tid = 0;
auto insert = [&](int V, int id) {
if (ct[V] == 2) return;
queue<int> q({V});
lgen[V] = id;
while (!q.empty()) {
int v = q.front();
q.pop();
ct[v]++;
for (int i = 0; i < (MAXB); i++)
if (v & (1 << i)) {
int vv = v ^ (1 << i);
if (ct[vv] < 2 && lgen[vv] != id) {
lgen[vv] = id;
q.push(vv);
}
}
}
};
int ans = 0;
for (int i = (N)-1; i >= 0; i--) {
if (i + 2 < N) {
int here = 0, need = 0;
for (int b = (MAXB)-1; b >= 0; b--) {
if (!(a[i] & (1 << b))) {
if (ct[need ^ (1 << b)] >= 2) {
need ^= 1 << b;
here ^= 1 << b;
}
} else {
here ^= 1 << b;
}
}
ckmax(ans, here);
}
insert(a[i], tid++);
}
ps(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000010];
struct _ {
int max_, se;
_ operator+(_ ob) {
_ rv;
if (max_ == ob.max_) {
rv.max_ = max_;
rv.se = max(se, ob.se);
return rv;
}
if (max_ < ob.max_) {
rv.max_ = ob.max_;
rv.se = max(ob.se, max_);
} else {
rv.max_ = max_;
rv.se = max(se, ob.max_);
}
return rv;
}
};
_ dp[2048576];
int main() {
int n;
scanf("%d", &n);
int i;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
dp[a[i]] = dp[a[i]] + (_){i, 0};
}
int j;
for (i = 2048575; i >= 0; i--) {
for (j = 0; j < 21; j++) {
if (i & 1 << j) {
dp[i ^ (1 << j)] = dp[i ^ (1 << j)] + dp[i];
}
}
}
int tmp, ans = 0;
for (i = 1; i <= n - 2; i++) {
tmp = 0;
for (j = 20; j >= 0; j--) {
if (a[i] & 1 << j) continue;
tmp ^= 1 << j;
if (dp[tmp].se <= i) tmp ^= 1 << j;
}
ans = max(ans, tmp | a[i]);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void getint(int &v) {
char ch, fu = 0;
for (ch = '*'; (ch < '0' || ch > '9') && ch != '-'; ch = getchar())
;
if (ch == '-') fu = 1, ch = getchar();
for (v = 0; ch >= '0' && ch <= '9'; ch = getchar()) v = v * 10 + ch - '0';
if (fu) v = -v;
}
struct node {
int x, y;
node() { x = y = -1; }
node(int X, int Y) { x = X, y = Y; }
node operator+(const node &A) const {
node B = A;
if (x > B.x) {
B.y = B.x;
B.x = x;
} else if (x > B.y)
B.y = x;
if (y > B.x) {
B.y = B.x;
B.x = y;
} else if (y > B.y)
B.y = y;
return B;
}
};
node a[2200000];
int b[1000010], n, ans;
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) getint(b[i]), a[b[i]] = a[b[i]] + node(i, -1);
for (int j = 0; j <= 20; ++j)
for (int i = 0; i <= (1 << 21) - 1; ++i)
if ((i >> j) & 1) a[i ^ (1 << j)] = a[i ^ (1 << j)] + a[i];
for (int i = 1; i <= n - 2; ++i) {
int t = 0;
for (int j = 20; j >= 0; --j) {
if ((b[i] >> j) & 1) continue;
if (a[t ^ (1 << j)].y > i) t ^= 1 << j;
}
ans = max(ans, b[i] ^ t);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e6 + (int)2e5;
int num[N];
int n;
struct node {
int mx1, mx2;
void add(int x) {
if (x > mx1) swap(mx1, x);
if (x > mx2) swap(mx2, x);
}
void merge(node &o) {
add(o.mx1);
add(o.mx2);
}
} nd[N];
struct FWT {
int N;
void FWTand(node *a) {
for (int mid = 1; mid < N; mid <<= 1)
for (int R = mid << 1, j = 0; j < N; j += R)
for (int k = 0; k < mid; k++) a[j + k].merge(a[j + k + mid]);
}
} fwt;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> num[i];
nd[num[i]].add(i);
}
fwt.N = (1 << 21);
fwt.FWTand(nd);
int fres = 0;
for (int i = 1; i <= n - 2; i++) {
int mask = 0;
int res = num[i];
for (int j = 20; j >= 0; j--) {
if (!((res >> j) & 1) && nd[mask | (1 << j)].mx2 > i) {
mask |= (1 << j);
res |= (1 << j);
}
}
fres = max(fres, res);
}
cout << fres << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, M = 2e6;
int n, a[N];
void enter() {
cin >> n;
for (int i = (1), _b = (n); i <= _b; ++i) cin >> a[i];
}
pair<int, int> dp[M + 12];
inline void add(int a, int b) {
if (dp[a].first == b || dp[a].second == b) return;
if (dp[a].second < b)
dp[a] = {dp[a].second, b};
else if (dp[a].first < b)
dp[a] = {b, dp[a].second};
}
bool can(int i, int x) { return dp[x].second && dp[x].first > i; }
void process() {
for (int i = (1), _b = (n); i <= _b; ++i) add(a[i], i);
for (int i = 0; i < 21; ++i) {
for (int mask = (M), _b = (0); mask >= _b; --mask) {
if ((1 << (i)) & mask) {
add(mask ^ (1 << (i)), dp[mask].first);
add(mask ^ (1 << (i)), dp[mask].second);
}
}
}
int ans = 0;
for (int i = (1), _b = (n - 2); i <= _b; ++i) {
int mask = 0;
for (int j = (20), _b = (0); j >= _b; --j)
if (!((1 << (j)) & a[i])) {
if (can(i, (1 << (j)) | mask)) {
mask |= (1 << (j));
}
}
ans = max(ans, a[i] | mask);
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
enter();
process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e6 + 233;
pair<int, int> f[maxn];
int a[maxn];
inline void update(pair<int, int>& t, int v) {
if (v > t.first)
t = make_pair(v, t.first);
else if (v > t.second)
t = make_pair(t.first, v);
}
int main() {
int n;
cin >> n;
for (int i = 0; i <= (1 << 21); i++) f[i] = make_pair(0, 0);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
update(f[a[i]], i);
}
for (int k = 0; k < 21; k++)
for (int i = (1 << 21) - 1; i; i--) {
if (i & (1 << k)) {
int j = i ^ (1 << k);
update(f[j], f[i].first);
update(f[j], f[i].second);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int cur = 0;
for (int k = 20; k >= 0; k--) {
if (((a[i] & (1 << k)) == 0) && f[cur | (1 << k)].second > i)
cur |= 1 << k;
}
if (f[cur].second > i) ans = max(ans, a[i] | cur);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 8100000;
int n, a[maxn], f[maxn], ans, lst[maxn];
void insert(int x, int y) {
if (f[x] >= 2 || lst[x] == y) return;
f[x]++;
lst[x] = y;
for (int i = 0; i <= 22; i++)
if (x & (1 << i)) insert(x ^ (1 << i), y);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
insert(a[n], n);
insert(a[n - 1], n - 1);
for (int i = n - 2; i >= 1; i--) {
int maxx = 0;
for (int j = 22; j >= 0; j--)
if (!(a[i] & (1 << j))) {
maxx |= (1 << j);
if (f[maxx] < 2) maxx ^= (1 << j);
}
ans = max(ans, a[i] | maxx);
insert(a[i], i);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
inline int rd() {
int first = 0;
char p = getchar();
while (p < '0' || p > '9') p = getchar();
while (p >= '0' && p <= '9') first = first * 10 + p - '0', p = getchar();
return first;
}
const int N = 3e6 + 10;
int n, a[N], vis[N], pre[N];
pair<int, int> dp[N];
void add(int s, int p) {
if (!dp[s].first) return dp[s].first = p, void();
if (!dp[s].second) return dp[s].second = p, void();
if (dp[s].first < p) dp[s].first = p;
if (dp[s].first > dp[s].second) swap(dp[s].first, dp[s].second);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i), add(a[i], i);
int mx = (1 << 21) - 1;
for (int i = 0; i <= 21; ++i)
for (int j = 0; j <= mx; ++j)
if (j >> i & 1) {
if (dp[j].first) add(j ^ 1 << i, dp[j].first);
if (dp[j].second) add(j ^ 1 << i, dp[j].second);
}
for (int i = 1; i <= n - 2; ++i) vis[i] = 1;
int ans = 0;
for (int d = 21; d >= 0; --d) {
for (int i = 1; i <= n; ++i)
if (vis[i]) {
if (a[i] >> d & 1 ^ 1) {
pre[i] ^= 1 << d;
if (!dp[pre[i]].second || dp[pre[i]].first <= i) vis[i] = -1;
}
}
for (int i = 1; i <= n; ++i)
if (vis[i] == 1) ans |= 1 << d;
for (int i = 1; i <= n; ++i)
if (vis[i] == -1) {
if (ans >> d & 1)
vis[i] = 0;
else
vis[i] = 1, pre[i] ^= 1 << d;
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int Left[1 << 21], Right[1 << 21][2], n;
void Put(int a, int b) {
if (Right[a][0] == b || Right[a][1] == b) return;
if (Right[a][1] >= b) return;
if (Right[a][0] < b) {
Right[a][1] = Right[a][0];
Right[a][0] = b;
} else
Right[a][1] = b;
}
bool Pos(int a) {
int i;
for (i = 0; i < (1 << 21); i++) {
int t = Right[i][1];
int tp = (a & (~i));
if (Left[tp] < t) {
return true;
}
}
return false;
}
int main() {
int i, j, k, a;
scanf("%d", &n);
for (i = 0; i < (1 << 21); i++) Left[i] = 1e9;
for (i = 1; i <= n; i++) {
scanf("%d", &a);
if (Left[a] > 1e8) Left[a] = i;
Right[a][1] = Right[a][0];
Right[a][0] = i;
}
for (i = (1 << 21) - 1; i >= 0; i--) {
for (j = 0; j < 21; j++) {
if ((i >> j) & 1) continue;
Left[i] = min(Left[i], Left[i ^ (1 << j)]);
Put(i, Right[i ^ (1 << j)][0]);
Put(i, Right[i ^ (1 << j)][1]);
}
}
int s = 0;
for (i = 20; i >= 0; i--) {
s += (1 << i);
if (!Pos(s)) s -= (1 << i);
}
printf("%d\n", s);
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.1415926535897932384626433832795;
const int inf = 1e9;
const long long inf2 = 1e18;
const int mod = 1e9 + 7;
void boost() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
const int N = (1 << 21) + 10;
vector<pair<int, int>> dp(N);
void update(int x, int p) {
if (dp[x].first < p) {
dp[x].second = dp[x].first;
dp[x].first = p;
} else if (dp[x].second < p && dp[x].first != p)
dp[x].second = p;
}
void solve() {
for (int i = 0; i < N; ++i) {
dp[i] = {-1, -1};
}
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; ++i) {
cin >> arr[i];
update(arr[i], i);
}
for (int i = 0; i < 20; i++) {
for (int mask = (1 << 21) - 1; mask > 0; mask--) {
if (((mask >> i) & 1) == 0) {
update(mask, dp[mask | (1 << i)].first);
update(mask, dp[mask | (1 << i)].second);
}
}
}
dp[0] = {inf, inf};
int x;
int ans = 0;
for (int i = 0; i < n - 2; i++) {
x = 0;
for (int j = 20; j >= 0; j--) {
if ((arr[i] >> j) & 1) continue;
if (dp[x | (1 << j)].second > i) {
x |= (1 << j);
}
}
if (dp[x].second != -1) ans = max(ans, x | arr[i]);
}
cout << ans << endl;
return;
}
int main() {
boost();
int tc = 1;
while (tc--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 3, M = 2e6 + 1e5, Rdx = 2e6 + 1e4;
template <typename T>
inline T Min(T A, T B) {
return A < B ? A : B;
}
template <typename T>
inline T Max(T A, T B) {
return A > B ? A : B;
}
template <typename T>
inline void redn(T &ret) {
static char ch;
ret = 0, ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) ret = (ret << 1) + (ret << 3) + ch - 48, ch = getchar();
}
int n, d[N], f[M], g[M], Mn[M], Mx;
inline void Mrg(int S, int T) {
if (f[S] < f[T]) {
g[S] = f[S], f[S] = f[T];
if (g[S] < g[T]) g[S] = g[T];
} else if (g[S] < f[T])
g[S] = f[T];
}
int main() {
redn(n);
memset(Mn, 127, sizeof Mn);
for (register int i = (1); i <= (n); ++i)
redn(d[i]), Mn[d[i]] = Min(Mn[d[i]], i), Mx = Max(Mx, d[i]);
for (register int i = (1); i <= (n); ++i) f[Rdx] = i, Mrg(d[i], Rdx);
int m = log2(Mx) + 1;
int siz = 1 << m;
siz--;
for (register int i = (0); i <= (m - 1); ++i)
for (register int S = (siz); S >= (0); --S)
if (!(S & (1 << i)))
Mrg(S, S ^ (1 << i)), Mn[S] = Min(Mn[S], Mn[S ^ (1 << i)]);
int Ans = 0;
for (register int i = (m); i >= (0); --i) {
static int S;
S = Ans | (1 << i);
static bool fl;
fl = 0;
for (int j = S; j; j = (j - 1) & S)
if (Mn[j ^ S] < g[j]) {
fl = 1;
break;
}
if (fl || Mn[S] < g[0]) {
Ans = S;
continue;
}
}
printf("%d\n", Ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5;
int n, ans;
int a[N];
int f[(1 << 21)][21];
void modify(int s, int k) {
if (k > 20) return;
if (f[s][k] >= 2) return;
f[s][k] += 1;
modify(s, k + 1);
if (s & (1 << k)) modify(s ^ (1 << k), k);
}
int main() {
scanf("%d\n", &n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = n; i; --i) {
int tmp = 0, now = 0;
if (i < n - 1) {
for (int j = 20; ~j; --j)
if (a[i] & (1 << j))
tmp |= (1 << j);
else if (f[now | (1 << j)][20] >= 2)
tmp |= (1 << j), now |= (1 << j);
}
modify(a[i], 0);
ans = max(ans, tmp);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct marray {
int value[2], size;
};
void merge(marray &x, const marray &y) {
for (int i = 0; i < y.size; ++i) {
if (x.size < 2) {
x.value[x.size++] = y.value[i];
} else {
if (x.value[0] < y.value[i]) {
x.value[0] = y.value[i];
} else if (x.value[1] < y.value[i]) {
x.value[1] = y.value[i];
}
}
if (x.size == 2 && x.value[0] > x.value[1]) {
swap(x.value[0], x.value[1]);
}
}
}
marray dp[2097152];
int a[2097152];
void init() {
for (int i = 0; i < 2097152; ++i) {
dp[i].size = 0;
}
}
void solve() {
init();
int n;
scanf("%d ", &n);
for (int i = 0; i < n; ++i) {
scanf("%d ", &a[i]);
marray tmp;
tmp.size = 1;
tmp.value[0] = i;
merge(dp[a[i]], tmp);
}
for (int bit = 0; bit < 21; ++bit) {
for (int i = 2097152 - 1; i >= 0; --i) {
if ((i & (1 << bit)) == 0) {
int g = i | (1 << bit);
assert(g < 2097152);
merge(dp[i], dp[g]);
}
}
}
int ret = 0;
for (int i = 0; i < n - 2; ++i) {
int maxBit = 0;
for (int bit = 21 - 1; bit >= 0; --bit) {
if (a[i] & (1 << bit)) {
continue;
}
int cur = maxBit | (1 << bit);
if (dp[cur].size == 2 && i < dp[cur].value[0]) {
maxBit = cur;
}
}
ret = max(ret, maxBit | a[i]);
}
printf("%d\n", ret);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.1415926535897932384626433832795;
const int inf = 1e9;
const long long inf2 = 1e18;
const int mod = 1e9 + 7;
void boost() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
const int N = (1 << 21) + 10;
vector<int> cnt(N, 0), lst(N, -1);
int ind;
void subenum(int x) {
if (cnt[x] == 2 || lst[x] == ind) return;
cnt[x]++;
lst[x] = ind;
int d = x;
while (d) {
subenum(x - (d & (-d)));
d -= (d & (-d));
}
}
void solve() {
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; ++i) cin >> arr[i];
int ans = 0, a;
for (int i = n - 1; i >= 0; i--) {
a = 0;
ind = i;
for (int j = 20; j >= 0; j--) {
a ^= (1 << j);
if (cnt[(a ^ arr[i]) & a] != 2) a ^= (1 << j);
}
ans = max(ans, a);
subenum(arr[i]);
}
cout << ans << endl;
return;
}
int main() {
boost();
int tc = 1;
while (tc--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long INF = 1e18;
const double eps = 1e-10;
const int maxn = 2e6 + 233;
int f[maxn], a[maxn], n;
void update(int x, int k) {
if (k > 20) return;
if (f[x] > 1) return;
if (k == 20) f[x]++;
update(x, k + 1);
if (x >> k & 1) update(x ^ (1 << k), k + 1);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
int res = 0;
for (int i = n; i >= 1; --i) {
int ans = 0, t = 0;
for (int j = 20; j >= 0; --j) {
if (a[i] >> j & 1)
ans |= 1 << j;
else if (f[t | (1 << j)] > 1)
ans |= 1 << j, t |= 1 << j;
}
update(a[i], 0);
if (i <= n - 2) res = max(res, ans);
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[1010101];
int f[1024576 * 2][21];
inline void add(int x, int k) {
if (k > 20) return;
if (f[x][k] >= 2) return;
f[x][k]++;
add(x, k + 1);
if ((x >> k) & 1) {
add(x ^ (1 << k), k);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
int ans = 0;
for (int i = n; i >= 1; --i) {
int res = a[i], must = 0;
for (register int j = 20; j >= 0; --j) {
if ((a[i] >> j) & 1) continue;
if (f[must | (1 << j)][20] >= 2) {
must |= (1 << j);
res |= (1 << j);
}
}
add(a[i], 0);
if (i <= n - 2) ans = max(ans, res);
}
printf("%d\n", ans);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.