text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long MOD2 = 998244353;
const long long N = (1LL << 22);
const long double pi = 3.14159265359;
long long ans, n, u[N];
pair<long long, long long> dp[N];
void update(long long ida, long long idb) {
if (dp[idb].first > dp[ida].second) {
if (dp[idb].first > dp[ida].first) {
dp[ida].second = max(dp[ida].first, dp[idb].second);
dp[ida].first = dp[idb].first;
} else
dp[ida].second = dp[idb].first;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) cin >> u[i];
for (long long i = 0; i < N; i++) dp[i] = make_pair(-1, -1);
for (long long i = n - 1; i >= 0; i--) {
if (dp[u[i]].first == -1)
dp[u[i]].first = i;
else if (dp[u[i]].second == -1)
dp[u[i]].second = i;
}
for (long long j = 0; j < 22; j++) {
for (long long i = N - 1; i >= 0; i--) {
if (((1LL << j) & i)) continue;
update(i, (i | (1LL << j)));
}
}
for (long long i = 0; i < n - 2; i++) {
long long tmp = 0;
for (long long j = 21; j >= 0; j--) {
if (((1LL << j) & u[i])) continue;
if (dp[(tmp | (1LL << j))].second > i) tmp |= (1LL << j);
}
ans = max(ans, (tmp | u[i]));
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e6 + 42, MX = (1 << 21) + 42;
int n, inp[nmax];
int nums[nmax], now[nmax], seen[MX];
vector<int> active;
int bits = 0;
void update(int pos, int number) {
if (pos >= bits) {
seen[number]++;
return;
}
if (seen[number] >= 2) return;
update(pos + 1, number);
if (((1 << pos) & number)) update(pos + 1, number - (1 << pos));
}
bool can(int b) {
bits++;
for (int i = 1; i <= n; i++) now[i] = nums[i];
for (int i = 1; i <= n; i++) {
if (((1 << b) & inp[i])) {
now[i] += (1 << (bits - 1));
}
}
memset(seen, 0, sizeof(seen));
int MX = (1 << (bits)) - 1;
for (int i = n; i >= 1; i--) {
if (seen[MX - now[i]] >= 2) return 1;
update(0, now[i]);
}
return 0;
}
int main() {
scanf("%i", &n);
for (int i = 1; i <= n; i++) scanf("%i", &inp[i]);
int output = 0;
for (int i = 20; i >= 0; i--) {
if (can(i)) {
output = output + (1 << i);
for (int j = 1; j <= n; j++) nums[j] = now[j];
} else
bits--;
}
printf("%i\n", output);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 5;
const int mod = 1e9 + 7;
int a[maxn];
pair<int, int> dp[1 << 21];
void add(int x, int id) {
if (dp[x].first == -1) {
dp[x].first = id;
} else if (dp[x].second == -1) {
if (dp[x].first == id) return;
dp[x].second = id;
if (dp[x].first < dp[x].second) swap(dp[x].first, dp[x].second);
} else if (dp[x].first < id) {
dp[x].second = dp[x].first;
dp[x].first = id;
} else if (dp[x].second < id) {
if (dp[x].first == id) return;
dp[x].second = id;
}
}
void merge(int x1, int x2) {
add(x1, dp[x2].first);
add(x1, dp[x2].second);
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
add(a[i], i);
}
int s = 1 << 21;
for (int j = 0; j < 21; j++) {
for (int i = 0; i < s; i++) {
if (!(i >> j & 1)) merge(i, i ^ (1 << j));
}
}
int ans = 0;
for (int i = 1; i <= n - 2; i++) {
int res = 0, d = 0;
for (int j = 20; j >= 0; j--) {
if (a[i] >> j & 1)
res |= (1 << j);
else {
int mi = min(dp[d | (1 << j)].first, dp[d | (1 << j)].second);
if (mi > i) res |= (1 << j), d |= (1 << j);
}
}
ans = max(ans, res);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int K = 21;
int g[1 << K][2];
int a[1 << K];
void merge(int x, int z) {
if (z > g[x][0]) {
g[x][1] = g[x][0];
g[x][0] = z;
} else
g[x][1] = max(g[x][1], z);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int i = 0, ThxDem = 1 << K; i < ThxDem; ++i) g[i][0] = g[i][1] = -1;
int n;
cin >> n;
for (int i = 0, ThxDem = n; i < ThxDem; ++i) cin >> a[i], merge(a[i], i);
for (int i = 0, ThxDem = K; i < ThxDem; ++i)
for (int j = 0, ThxDem = 1 << K; j < ThxDem; ++j)
if (j & (1 << i)) {
merge(j ^ (1 << i), g[j][0]);
merge(j ^ (1 << i), g[j][1]);
}
long long ans = 0;
for (int i = 0, ThxDem = n - 2; i < ThxDem; ++i) {
long long now = a[i], msk = 0;
for (int j = K - 1; j >= 0; j--) {
if (!(now & (1 << j)) && g[msk | (1 << j)][1] > i) {
msk |= 1 << j;
}
}
ans = max(ans, now | msk);
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, dp[1 << 21];
vector<int> a;
void add(int x, int b) {
if (dp[x] == 2) return;
dp[x]++;
for (int i = b; i < 21; i++) {
if ((x >> i) & 1) add(x ^ (1 << i), i + 1);
}
}
int calc(int x) {
int ret = 0;
for (int i = 20; i >= 0; i--) {
if (((x >> i) & 1) == 0 && dp[ret ^ (1 << i)] == 2) {
ret ^= 1 << i;
}
}
return ret | x;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
a.resize(n);
for (auto &i : a) cin >> i;
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (i + 2 < n) ans = max(ans, calc(a[i]));
add(a[i], 0);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
#pragma optimize("-O3")
inline long long read() {
long long x = 0;
int f = 0;
char ch = getchar();
while (ch < '0' || ch > '9') f |= (ch == '-'), ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return x = f ? -x : x;
}
inline void write(long long x, bool f) {
if (x == 0) {
putchar('0');
if (f) putchar('\n');
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
static char s[23];
int l = 0;
while (x != 0) s[l++] = x % 10 + 48, x /= 10;
while (l) putchar(s[--l]);
if (f) putchar('\n');
}
constexpr int lowbit(int x) { return x & (-x); }
template <class T>
T big(const T &a1, const T &a2) {
return a1 > a2 ? a1 : a2;
}
template <class T>
T sml(const T &a1, const T &a2) {
return a1 < a2 ? a1 : a2;
}
template <typename T, typename... R>
T big(const T &f, const R &...r) {
return big(f, big(r...));
}
template <typename T, typename... R>
T sml(const T &f, const R &...r) {
return sml(f, sml(r...));
}
void debug_out() { cout << '\n'; }
template <typename T, typename... R>
void debug_out(const T &f, const R &...r) {
cout << f << " ";
debug_out(r...);
}
const char ptout[] = "%lld";
template <typename T>
void print(const T &f) {
printf(ptout, f);
putchar('\n');
}
template <typename T, typename... R>
void print(const T &f, const R &...r) {
printf(ptout, f);
putchar(' ');
print(r...);
}
const int HMOD[] = {1000000009, 1004535809};
const long long BASE[] = {1572872831, 1971536491};
const long long INFLL = 0x3f3f3f3f3f3f3f3fLL;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int MOD = 1e9 + 7;
const int MXN = 3e6 + 5;
const int MXE = 2e6 + 6;
int n, m;
int ans, LN;
int ar[MXN], dp[MXN][21];
void update(int x, int k) {
if (k > 20) return;
if (dp[x][k] > 1) return;
++dp[x][k];
if (x & (1 << k)) {
update(x ^ (1 << k), k);
}
update(x, k + 1);
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
ar[i] = read();
}
LN = 1 << 21;
for (int i = n; i >= 1; --i) {
int tmp = 0, have = 0;
for (int j = 20; j >= 0; --j) {
if (ar[i] & (1 << j)) {
tmp |= (1 << j);
} else {
if (dp[have | (1 << j)][20] >= 2) {
tmp |= (1 << j);
have |= (1 << j);
}
}
}
update(ar[i], 0);
if (i <= n - 2) ans = max(ans, tmp);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000010;
pair<int, int> dp[1 << 21];
int a[maxn];
void update(int mask, int val) {
if (dp[mask].second == 0) {
dp[mask].second = val;
return;
}
if (dp[mask].first == val || dp[mask].second == val) return;
if (val > dp[mask].second) {
dp[mask].first = dp[mask].second;
dp[mask].second = val;
} else if (val > dp[mask].first) {
dp[mask].first = val;
}
}
void merge(int mask1, int mask2) {
if (dp[mask2].first != 0) update(mask1, dp[mask2].first);
if (dp[mask2].second != 0) update(mask1, dp[mask2].second);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
update(a[i], i);
}
for (int i = 0; i < 21; i++) {
for (int j = 0; j < (1 << 21); j++) {
if ((j >> i) & 1) {
merge(j ^ (1 << i), j);
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int mask = 0, tmp = (1 << 21) - 1 - a[i];
for (int j = 20; j >= 0; j--) {
if ((tmp >> j) & 1) {
if (dp[mask ^ (1 << j)].first > i && dp[mask ^ (1 << j)].second != 0) {
mask ^= (1 << j);
}
}
}
if (dp[mask].first > i && dp[mask].second != 0) ans = max(ans, a[i] | mask);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5, mod = 1e9 + 7;
int t, first[N][2], n, a[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
int mx = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
swap(first[a[i]][0], first[a[i]][1]);
first[a[i]][0] = i;
mx = max(mx, a[i]);
}
for (int i = mx; i >= 0; i--) {
for (int j = 0; j <= 20; j++) {
if ((1 << j) & i) {
int x = (1 << j) ^ i;
if (first[x][0] < first[i][0]) {
first[x][1] = max(first[x][0], first[i][1]);
first[x][0] = first[i][0];
} else if (first[x][0] != first[i][0])
first[x][1] = max(first[x][1], first[i][0]);
else
first[x][1] = max(first[x][1], first[i][1]);
}
}
}
int Ans = 0;
for (int i = 1; i < n - 1; i++) {
int bef = 0, ans = 0;
for (int j = 20; j >= 0; j--) {
if ((1 << j) & a[i]) {
ans += 1 << j;
continue;
}
if (first[bef + (1 << j)][1] > i) {
ans += 1 << j;
bef += 1 << j;
}
}
Ans = max(Ans, ans);
}
cout << Ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[2100005], f[2100005][2];
inline void Add(int v, int x) {
if (f[v][0] < x)
f[v][1] = f[v][0], f[v][0] = x;
else if (f[v][1] < x)
f[v][1] = x;
}
signed main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
Add(a[i], i);
}
for (int i = 0; i < 21; i++)
for (int j = 0; j < (1 << 21); j++) {
if (j & (1 << i)) continue;
if (f[j | (1 << i)][0] != 0) Add(j, f[j | (1 << i)][0]);
if (f[j | (1 << i)][1] != 0) Add(j, f[j | (1 << i)][1]);
}
int ans = 0;
for (int i = 1; i <= n - 2; i++) {
int res = 0;
for (int j = 20; j >= 0; j--) {
if (!(a[i] & (1 << j))) {
res |= 1 << j;
if (f[res][1] <= i) res ^= 1 << j;
}
}
ans = max(ans, res | a[i]);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 21) - 1;
int ans, n, mx1[N + 10], mx2[N + 10], a[N + 10];
vector<int> mx;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
mx2[N - a[i]] = mx1[N - a[i]];
mx1[N - a[i]] = i;
}
for (int j = 0; j <= 21; j++) {
for (int i = 0; i <= N; i++) {
if (i & (1 << j)) {
int x = i ^ (1 << j);
mx.clear();
mx.push_back(mx1[x]);
mx.push_back(mx2[x]);
mx.push_back(mx1[i]);
mx.push_back(mx2[i]);
sort(mx.begin(), mx.end());
reverse(mx.begin(), mx.end());
mx1[i] = mx[0];
mx2[i] = mx[1];
}
}
}
for (int i = 1; i <= n - 2; i++) {
int best = 0;
int mask = N - a[i];
for (int j = 21; j >= 0; j--) {
if (!(mask & (1 << j))) continue;
int best1 = best + (1 << j);
if (mx2[N - best1] > i) best = best1;
}
ans = max(ans, a[i] + best);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmin(T &a, T b) {
a = min(a, b);
}
template <typename T>
void chkmax(T &a, T b) {
a = max(a, b);
}
inline int fread(void) {
int ret = 0, op = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') op = -1;
for (; isdigit(ch); ch = getchar()) ret = (ret << 1) + (ret << 3) - '0' + ch;
return ret * op;
}
const int MAXN = 3e6 + 10;
const int INF = 0x3f3f3f3f;
const int MAXM = 22 + 10;
pair<int, int> f[MAXN];
int n, a[MAXN];
pair<int, int> smax(pair<int, int> x, pair<int, int> y) {
if (x.first < y.first) swap(x, y);
pair<int, int> ret = x;
ret.second = max(x.second, y.first);
return ret;
}
inline void init(void) {
n = fread();
for (int i = 1; i <= n; ++i) {
a[i] = fread();
f[a[i]] = smax(f[a[i]], make_pair(i, -INF));
}
}
void SoSDP(void) {
for (int i = 0; i < 21; ++i) {
for (int mask = 0; mask < (1 << 21); ++mask) {
if (!((mask >> i) & 1)) {
f[mask] = smax(f[mask], f[mask | (1 << i)]);
}
}
}
}
bool check(int S, int pos) { return f[S].second > pos; }
inline void work(void) {
SoSDP();
int ans = 0;
for (int i = 1; i <= n - 2; ++i) {
int now = 0;
for (int j = 21; j >= 0; --j) {
if ((a[i] >> j) & 1) continue;
if (check(now ^ (1 << j), i)) now ^= (1 << j);
}
ans = max(ans, now | a[i]);
}
printf("%d", ans);
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ans, n, vis[2000007], a[1000007], cnt[4000007];
void Insert(int x, int id) {
if (cnt[x] == 2) return;
if (vis[x] == id) return;
++cnt[x];
for (int i = 0; i <= 20; ++i)
if ((x & (1 << i)) && (vis[x ^ (1 << i)] != id)) {
Insert(x ^ (1 << i), id);
vis[x ^ (1 << i)] = id;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
ans = a[1] | (a[2] & a[3]);
for (int i = n; i >= 1; --i) {
int sum = 0;
for (int j = 20; j >= 0; --j)
if ((!(a[i] & (1 << j))) && cnt[sum | (1 << j)] >= 2) sum |= (1 << j);
if (sum || (cnt[0] == 2)) ans = max(ans, a[i] | sum);
Insert(a[i], i);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 3, S = 21;
struct data {
int a, b;
inline friend void merge(data &x, data &y) {
x.b = max(min(x.a, y.a), max(x.b, y.b));
x.a = max(x.a, y.a);
}
};
data f[N];
int a[N];
int main() {
int n, mx = 0, s;
scanf("%d", &n);
for (register int i = 1; i <= n; i++) {
scanf("%d", a + i);
mx = max(mx, a[i]);
}
s = 31 - __builtin_clz(mx);
for (register int i = n; i; i--) {
if (!f[a[i]].a)
f[a[i]].a = i;
else if (f[a[i]].a && !f[a[i]].b)
f[a[i]].b = i;
}
for (register int i = 1; i <= mx; i <<= 1)
for (register int j = i; j <= mx; j += i << 1)
for (register int k = j; k < j + i && k <= mx; k++) merge(f[k ^ i], f[k]);
int ans = 0;
for (register int i = 1; i <= n - 2; i++) {
int nw = 0;
for (register int j = s, k = 1 << s; ~j; j--, k >>= 1)
if (!(a[i] & k) && f[nw | k].b > i) nw |= k;
ans = max(ans, a[i] | nw);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class C>
void mini(C &a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C &a4, C b4) {
a4 = max(a4, b4);
}
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
const long long C = 21;
const long long MAX = 1 << C;
vector<long long> pier, ost, dru, t;
long long n;
void dodaj_pier(long long id, long long val) {
(id, val);
if (pier[val] == n) {
pier[val] = id;
for (long long bit = (0); bit <= ((long long)(C)-1); bit++)
if ((val >> bit) & 1) {
dodaj_pier(id, val - (1 << bit));
}
}
}
void dodaj_ost(long long id, long long val) {
if (ost[val] != id && (ost[val] == -1 || dru[val] == -1)) {
if (ost[val] == -1)
ost[val] = id;
else
dru[val] = id;
for (long long bit = (0); bit <= ((long long)(C)-1); bit++)
if ((val >> bit) & 1) {
dodaj_ost(id, val - (1 << bit));
}
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(11);
if (0) cout << fixed << setprecision(6);
cin >> n;
t.resize(n);
pier.resize(MAX, n);
ost.resize(MAX, -1);
dru.resize(MAX, -1);
for (long long i = (0); i <= ((long long)(n)-1); i++) cin >> t[i];
for (long long i = (0); i <= ((long long)(n)-1); i++) {
dodaj_pier(i, t[i]);
}
for (long long i = n - 1; i >= 0; i--) {
dodaj_ost(i, t[i]);
}
(pier, ost, dru);
(pier[0], dru[0], dru[4]);
long long res = 0;
vector<pair<long long, long long> > ok;
ok.push_back({0ll, 0ll});
for (long long bit = C - 1; bit >= 0; bit--) {
long long pom = 1 << bit;
vector<pair<long long, long long> > ok2;
for (pair<long long, long long> el : ok) {
if (pier[el.first + pom] < dru[el.second]) {
ok2.push_back({el.first + pom, el.second});
}
if (pier[el.first] < dru[el.second + pom]) {
ok2.push_back({el.first, el.second + pom});
}
}
if (((long long)(ok2).size())) {
res += pom;
swap(ok, ok2);
}
(ok);
}
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1123456;
int n, ans, clk;
int a[maxn], cnt[2 * maxn], vis[2 * maxn];
void dfs(int u) {
if (vis[u] == clk) return;
if (cnt[u] >= 2) return;
cnt[u]++;
vis[u] = clk;
for (int(i) = (21); (i) >= (0); (i)--)
if (u & (1 << i)) dfs(u ^ (1 << i));
}
int main() {
scanf("%d", &n);
for (int(i) = (1); (i) <= (n); (i)++) scanf("%d", a + i);
for (int(i) = (n); (i) >= (1); (i)--) {
if (i <= n - 2) {
int mask = 0, cur = 0;
for (int(j) = (21); (j) >= (0); (j)--) {
if (a[i] & (1 << j)) {
mask |= 1 << j;
continue;
}
if (cnt[cur | (1 << j)] >= 2) {
mask |= 1 << j;
cur |= 1 << j;
}
}
ans = max(ans, mask);
}
++clk;
dfs(a[i]);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000100, MAXLA = 21;
int n, a[MAXN], f[(1 << MAXLA)][4], ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]), f[a[i]][0] = i, sort(f[a[i]], f[a[i]] + 4);
for (int i = 0, mask; i < MAXLA; ++i)
for (mask = 0; mask < (1 << MAXLA); ++mask)
if (mask & (1 << i))
f[mask ^ (1 << i)][0] = f[mask][2], f[mask ^ (1 << i)][1] = f[mask][3],
sort(f[mask ^ (1 << i)], f[mask ^ (1 << i)] + 4);
for (int i = 1, j, cur = 0; i <= n - 2; ++i, cur = 0) {
for (j = MAXLA - 1; j >= 0; --j)
if (((a[i] >> j) & 1) == 0 && f[cur | (1 << j)][2] > i) cur |= (1 << j);
ans = max(ans, cur | a[i]);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4000005;
int n, cnt[N], ans, a[N];
void insert(int x, int y) {
if (cnt[x | y] == 2) return;
if (x == 0) {
cnt[y]++;
return;
}
insert(x - (x & -x), y | x & -x);
insert(x - (x & -x), y);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = n; i >= 1; i--) {
if (i + 2 <= n) {
int now = 0;
for (int j = 20; j >= 0; j--)
if (!((1 << j) & a[i]) && cnt[now | 1 << j] == 2) now |= 1 << j;
ans = max(ans, now | a[i]);
}
insert(a[i], 0);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
template <typename T1, typename T2>
void ckmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
void ckmax(T1 &a, T2 b) {
if (a < b) a = b;
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
int read() {
int x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = 10 * x + ch - '0', ch = getchar();
return f ? -x : x;
}
const int N = 3000005;
int a[N], mx[N][2], n;
void update(int u, int id) {
if (mx[u][0] <= id)
mx[u][1] = mx[u][0], mx[u][0] = id;
else if (mx[u][1] <= id)
mx[u][1] = id;
}
int getans(int w, int id) {
int S = 0;
if (mx[0][1] <= id) return 0;
for (register int j = 20; j >= 0; j--)
if (w >> j & 1) {
S |= 1 << j;
if (mx[S][1] < id) S ^= 1 << j;
}
return S ^ a[id];
}
int main() {
n = read();
for (register int i = 1; i <= n; i++) {
a[i] = read();
update(a[i], i);
}
for (register int j = 0; j <= 20; j++) {
for (register int i = (1 << 21) - 1; i >= 0; i--) {
if (i >> j & 1) continue;
int qwq = i | 1 << j;
update(i, mx[qwq][0]), update(i, mx[qwq][1]);
}
}
int ans = 0;
for (register int i = 1; i <= n; i++) {
ckmax(ans, getans((1 << 21) - 1 - a[i], i));
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 21, bit = 21;
int a[N], counter[N + 5];
void upd(int mask, int k) {
if (counter[mask] < 2) {
counter[mask]++;
for (; k < bit; k++) {
if (mask & (1 << k)) upd(mask ^ (1 << k), k + 1);
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = n - 1; ~i; i--) {
if (counter[0] >= 2) {
int mask = 0;
for (int j = bit - 1; ~j; j--) {
if (a[i] & (1 << j)) continue;
if (counter[mask | (1 << j)] > 1) mask |= (1 << j);
}
ans = max(ans, (a[i] | mask));
}
upd(a[i], 0);
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> merge(pair<int, int> a, pair<int, int> b) {
if (a.first < b.first) {
swap(a, b);
}
int i, j;
if (b.second > a.first) {
i = b.second;
j = a.second;
return {min(i, j), max(i, j)};
} else {
return a;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
const int MAX = 21;
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<pair<int, int>> dp(1 << MAX, {-1, -1});
for (int i = 0; i < n; i++) {
dp[a[i]] = merge(dp[a[i]], {-1, i});
}
for (int bit = 0; bit < MAX; bit++) {
for (int mask = 0; mask < (1 << MAX); mask++) {
if (mask & (1 << bit)) {
dp[mask ^ (1 << bit)] = merge(dp[mask ^ (1 << bit)], dp[mask]);
}
}
}
int ans = 0;
for (int i = 0; i < n - 2; i++) {
int cur = 0;
for (int j = MAX - 1; j >= 0; j--) {
if (a[i] & (1 << j)) {
continue;
}
if (dp[cur | (1 << j)].first > i) {
cur |= (1 << j);
}
}
ans = max(ans, a[i] | cur);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000010], f[1 << 23];
void updata(int x, int d) {
if (f[x] >= 2) return;
if (d == -1) {
f[x]++;
return;
}
updata(x, d - 1);
if (x & (1 << d)) updata(x ^ (1 << d), d - 1);
}
int query(int x) {
int ans = 0;
for (int i = 22; i >= 0; i--) {
if ((x & (1 << i)) == 0 && (f[ans | (1 << i)] >= 2)) ans |= 1 << i;
}
return x | ans;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int ans = 0;
for (int i = n; i; i--) {
if (i <= n - 2) ans = max(ans, query(a[i]));
updata(a[i], 22);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
int inf = 100000000;
pair<int, int> masks[1 << 21];
int arr[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin.exceptions(cin.failbit);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < (1 << 21); i++) {
masks[i].first = -1;
masks[i].second = -1;
}
for (int i = 0; i < n; i++) {
if (masks[arr[i]].first < i) {
masks[arr[i]].second = masks[arr[i]].first;
masks[arr[i]].first = i;
} else if (masks[arr[i]].second < i) {
masks[arr[i]].second = i;
}
}
for (int i = (1 << 21) - 1; i >= 0; i--) {
for (int a = 0; a <= 20; a++) {
if ((1 << a) & i) {
int mask = i - (1 << a);
if (masks[mask].first < masks[i].first) {
masks[mask].second = masks[mask].first;
masks[mask].first = masks[i].first;
} else if (masks[mask].first != masks[i].first &&
masks[mask].second < masks[i].first) {
masks[mask].second = masks[i].first;
}
if (masks[mask].first != masks[i].second &&
masks[mask].second < masks[i].second) {
masks[mask].second = masks[i].second;
}
}
}
}
int ans = 0;
for (int i = n - 3; i >= 0; i--) {
int mask = (1 << 21) - 1 - arr[i];
int pattern = 0;
for (int a = 20; a >= 0; a--) {
if (mask & (1 << a)) {
if (masks[pattern + (1 << a)].second > i) {
pattern += (1 << a);
}
}
}
ans = max(ans, pattern | arr[i]);
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(1e6) + 10, B = 21;
int n, a[N];
pair<int, int> f[1 << B];
void ins(int p, int pos) {
if (pos > f[p].first)
f[p].second = f[p].first, f[p].first = pos;
else if (pos > f[p].second)
f[p].second = pos;
}
bool chk(int p, int pos) { return f[p].second > pos; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = (1), iz = (n); i <= iz; i++) cin >> a[i], ins(a[i], i);
for (int k = (0), kz = (B - 1); k <= kz; k++)
for (int j = (0), jz = ((1 << B) - 1); j <= jz; j++)
if (!(j & (1 << k)))
ins(j, f[j ^ (1 << k)].first), ins(j, f[j ^ (1 << k)].second);
int res = 0;
for (int i = (1), iz = (n - 2); i <= iz; i++) {
int cur = 0;
for (int k = (B - 1), kz = (0); k >= kz; k--)
if (!(a[i] & (1 << k)))
if (chk(cur | (1 << k), i)) cur |= (1 << k);
res = max(res, a[i] | cur);
}
return cout << res, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxbits = 21;
int dp[3][(1 << 21)];
bool dfs(int target, int b, int A, int B, int d) {
if (d == b) {
return (dp[0][A] < dp[1][B]) && (dp[0][A] != -1) && (dp[1][B] != -1);
}
if (target & (1 << d)) {
if (dfs(target, b, A | (1 << d), B, d + 1)) return 1;
if (dfs(target, b, A, B | (1 << d), d + 1)) return 1;
return 0;
}
return dfs(target, b, A, B, d + 1);
}
int solve(int N, int* a) {
int best = 0;
for (int i = 1; i <= maxbits; i++) {
memset(dp, 255, sizeof(dp));
for (int j = 0; j < N; j++) {
int mask = a[j] >> (maxbits - i);
if (dp[0][mask] == -1) dp[0][mask] = j;
dp[1][mask] = dp[2][mask];
dp[2][mask] = j;
}
for (int mask = (1 << i) - 1; mask >= 0; mask--) {
for (int j = 0; j < i; j++) {
int superset = mask | (1 << j);
if (superset > mask) {
int minval = min(dp[0][mask], dp[0][superset]);
if (minval == -1) minval = max(dp[0][mask], dp[0][superset]);
dp[0][mask] = minval;
if (dp[2][superset] > dp[2][mask]) {
dp[1][mask] = dp[2][mask];
dp[2][mask] = dp[2][superset];
}
dp[1][mask] = max(dp[1][mask], dp[1][superset]);
if (dp[2][mask] > dp[2][superset])
dp[1][mask] = max(dp[1][mask], dp[2][superset]);
}
}
}
if (dfs((best << 1) + 1, i, 0, 0, 0))
best = (best << 1) + 1;
else
best <<= 1;
}
return best;
}
int brute_force(int N, int* a) {
int best = 0;
for (int i = 0; i < N - 2; i++)
for (int j = i + 1; j < N - 1; j++)
for (int k = j + 1; k < N; k++) best = max(best, a[i] | (a[j] & a[k]));
return best;
}
void test_correctness() {
srand(time(0));
while (1) {
int N = rand() % 50 + 3;
int a_max = rand() % 2000000;
int* a = new int[N];
for (int i = 0; i < N; i++) a[i] = rand() % a_max;
int res1 = brute_force(N, a);
auto t1 = std::chrono::high_resolution_clock::now();
int res2 = solve(N, a);
auto t2 = std::chrono::high_resolution_clock::now();
auto time =
std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count();
cout << N << " " << a_max << " " << res1 << " " << res2 << " "
<< (res1 == res2 ? "OK" : "ERROR!!!!!!!!!!!!!!!") << " "
<< double(time / 1000) << "ms" << endl;
}
}
void test_time() {
srand(time(0));
while (1) {
int N = 1000000;
int* a = new int[N];
for (int i = 0; i < N; i++) a[i] = rand() % 2000000;
auto t1 = std::chrono::high_resolution_clock::now();
int res = solve(N, a);
auto t2 = std::chrono::high_resolution_clock::now();
auto time =
std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count();
cout << res << " " << double(time / 1000) << "ms" << endl;
}
}
int main() {
int N;
cin >> N;
int* a = new int[N];
for (int i = 0; i < N; i++) cin >> a[i];
cout << solve(N, a) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
int n;
int a[N];
int vis[1 << 21];
bool trie[1 << 22];
void cover(int x) {
if (trie[x | (1 << 21)]) return;
int v = x | (1 << 21);
while (v) {
trie[v] = true;
v >>= 1;
}
for (int i = 0; i <= 20; ++i)
if ((x >> i) & 1) cover(x ^ (1 << i));
}
void dfs1(int x, int i) {
if (trie[x | (1 << 21)]) return;
if (vis[x] == i) return;
if (vis[x]) return cover(x);
vis[x] = i;
for (int k = 0; k <= 20; ++k)
if ((x >> k) & 1) dfs1(x ^ (1 << k), i);
}
int qry(int x) {
int o = 1;
for (int i = 20; i >= 0; --i) {
if ((x >> i) & 1)
o <<= 1;
else if (trie[(o << 1) | 1]) {
x |= 1 << i;
o = (o << 1) | 1;
} else
o <<= 1;
}
return x;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
int ans = 0;
for (int i = n; i; --i) {
if (i <= n - 2) ans = max(ans, qry(a[i]));
dfs1(a[i], i);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
int A[1000005];
int ans;
const int maxBit = 21;
pair<int, int> Max[4000005];
void updateMax(pair<int, int>& curr, int val) {
if (curr.first == val || curr.second == val) return;
if (curr.first < val) {
curr.second = curr.first;
curr.first = val;
} else if (curr.second < val)
curr.second = val;
}
void precalcMax() {
for (int i = N; i >= 1; i--) {
updateMax(Max[A[i]], i);
}
for (int i = (1 << maxBit) - 1; i >= 0; i--) {
for (int j = 0; j < maxBit; j++) {
if (!(i & (1 << j))) {
updateMax(Max[i], Max[i ^ (1 << j)].first);
updateMax(Max[i], Max[i ^ (1 << j)].second);
}
}
}
}
void Read() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d", &A[i]);
}
void Solve() {
for (int i = N - 2; i >= 1; i--) {
int mask = ((1 << maxBit) - 1) ^ (A[i]);
int res = 0;
for (int j = maxBit - 1; j >= 0; j--) {
if (!(mask & (1 << j))) continue;
if (Max[res ^ (1 << j)].second > i) res ^= (1 << j);
}
ans = max(ans, res | A[i]);
}
printf("%d\n", ans);
}
int main() {
Read();
precalcMax();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int n;
int dp[1 << 21][21];
int a[maxn];
void upd(int num, int k) {
if (k > 20) return;
if (dp[num][k] > 1) return;
dp[num][k]++;
upd(num, k + 1);
if (num >> k & 1) upd(num ^ (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 = 0, cnt = 0;
for (int j = 20; j >= 0; j--) {
if (a[i] >> j & 1)
res |= (1 << j);
else {
if (dp[cnt | (1 << j)][20] > 1) {
res |= (1 << j);
cnt |= (1 << j);
}
}
}
if (n - i >= 2) ans = max(ans, res);
upd(a[i], 0);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
const int LG = 22, N = (1 << LG);
int n, a[N], cnt[N], last[N];
bool mark[N];
vector<int> vec[N];
void go(int p, int ind) {
if (last[p] == ind || cnt[p] >= 2) return;
last[p] = ind;
cnt[p]++;
if (cnt[p] == 2) vec[ind].push_back(p);
for (int i = 0; i < LG; i++)
if (p >> i & 1) go(p ^ (1 << i), ind);
}
inline bool check(int x) {
for (int i = n - 1; i >= 0; i--) {
if (i < n - 2) {
int want = x - (x & a[i]);
if (mark[want]) return 1;
}
for (int x : vec[i]) mark[x] = 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = n - 1; i >= 0; i--) {
go(a[i], i);
}
int ans = 0;
for (int i = LG - 1; i >= 0; i--) {
memset(mark, 0, sizeof mark);
if (check(ans | (1 << i))) ans |= (1 << i);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
inline void read(int& x) {
x = 0;
int 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();
}
x *= f;
}
const int M = (1 << 21) + 7;
vector<int> pos[M];
inline void addPos(vector<int>& ms, int p) {
if (ms.empty())
ms.push_back(p);
else if (ms.size() == 1) {
if (ms[0] > p) {
ms.push_back(p);
swap(ms[0], ms[1]);
} else if (ms[0] < p)
ms.push_back(p);
} else {
if (ms[0] > p)
;
else if (ms[1] != p)
ms[0] = p;
if (ms[0] > ms[1]) swap(ms[0], ms[1]);
}
}
inline void upd(vector<int>& A, vector<int>& B) {
for (int e : B) addPos(A, e);
}
int main() {
int n;
read(n);
vector<int> a(n + 1);
int maxi = 0;
for (int i = 1; i <= n; ++i) {
read(a[i]);
maxi = max(maxi, a[i]);
addPos(pos[a[i]], i);
}
for (int m = maxi; m; --m) {
for (int b = 0; b < 22; ++b)
if (~m >> b & 1) {
if ((m | (1 << b)) <= maxi) upd(pos[m], pos[m | (1 << b)]);
}
}
int ans = 0;
for (int i = 1; i <= n - 2; ++i) {
int cur = 0;
for (int b = 21; ~b; --b) {
if (~a[i] >> b & 1) {
auto& it = pos[cur | 1 << b];
if (it.size() == 2 && *it.begin() > i) {
cur |= 1 << b;
}
}
}
ans = max(ans, a[i] | cur);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int BITS = 21;
const int MAX_VAL = (1 << BITS);
bool bit(int val, int pos) { return ((val >> pos) & 1); }
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> cnt(MAX_VAL);
function<void(int, int)> dfs = [&](int mask, int pos) {
if (cnt[mask] == 2) return;
cnt[mask]++;
for (int i = pos; i < BITS; i++) {
if (bit(mask, i)) dfs(mask ^ (1 << i), i + 1);
}
};
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (i <= n - 3) {
int mask = 0;
for (int j = BITS - 1; j >= 0; j--) {
if (!bit(a[i], j) && (cnt[mask | (1 << j)] == 2)) mask |= (1 << j);
}
ans = max(ans, a[i] | mask);
}
dfs(a[i], 0);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e6 + 5;
const int LOG = 21;
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long sq(long long x) { return (x * x) % MOD; }
long long modP(long long a, long long b) {
return (!b ? 1 : (sq(modP(a, b / 2)) * (b % 2 ? a : 1)) % MOD);
}
int a[maxN];
pair<int, int> dp[(1 << LOG)];
pair<int, int> operator+(pair<int, int> A, pair<int, int> B) {
int b[4];
b[0] = A.first;
b[1] = A.second;
b[2] = B.first;
b[3] = B.second;
sort(b, b + 4);
return {b[3], b[2]};
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(dp, -1, sizeof dp);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int b[3];
b[0] = i;
b[1] = dp[a[i]].first;
b[2] = dp[a[i]].second;
sort(b, b + 3);
dp[a[i]] = {b[2], b[1]};
}
for (int i = 0; i < LOG; i++) {
for (int mask = 0; mask < (1 << LOG); mask++) {
if (mask & (1 << i)) continue;
dp[mask] = dp[mask] + dp[mask ^ (1 << i)];
}
}
int ans = 0;
for (int i = 0; i < n - 2; i++) {
int x = 0;
for (int j = LOG - 1; j > -1; j--) {
if (a[i] & (1 << j)) continue;
if (dp[x ^ (1 << j)].second > i) x ^= (1 << j);
}
ans = max(ans, x | a[i]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
pair<int, int> pos[1 << 21];
int a[maxn];
void update(int mask, int id) {
pair<int, int>& p = pos[mask];
if (p.second == -1) return p.second = id, void();
if (p.first == -1) {
if (p.second == id) return;
p.first = id;
if (p.first > p.second) swap(p.first, p.second);
return;
}
if (id == p.second || id <= p.first) return;
if (id < p.second)
p.first = id;
else
p.first = p.second, p.second = id;
}
int main() {
for (int i = 0; i < (1 << 21); i++) pos[i] = make_pair(-1, -1);
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
update(a[i], i);
}
for (int i = 0; i < 21; i++) {
for (int mask = 0; mask < (1 << 21); mask++)
if (mask & (1 << i)) {
int now = mask ^ (1 << i);
if (pos[mask].first != -1) update(now, pos[mask].first);
if (pos[mask].second != -1) update(now, pos[mask].second);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int need = ((1 << 21) - 1) ^ a[i];
int tmp = 0;
for (int j = 20; j >= 0; j--)
if (need & (1 << j)) {
if (pos[tmp ^ (1 << j)].first > i) tmp ^= (1 << j);
}
if (pos[tmp].first > i) ans = max(ans, a[i] ^ tmp);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class X, class Y>
bool minimize(X &x, const Y &y) {
X eps = 1e-9;
if (x > y + eps) {
x = y;
return true;
} else
return false;
}
template <class X, class Y>
bool maximize(X &x, const Y &y) {
X eps = 1e-9;
if (x + eps < y) {
x = y;
return true;
} else
return false;
}
template <class T>
T Abs(const T &x) {
return (x < 0 ? -x : x);
}
int a[1000100], n;
int score[(1LL << (21)) + 7];
void init(void) {
scanf("%d", &n);
for (int i = (1), _b = (n); i <= _b; i++) scanf("%d", &a[i]);
}
queue<int> q;
bool inQueue[(1LL << (21)) + 7];
void addNumber(int x) {
queue<int> q;
q.push(x);
inQueue[x] = true;
while (!q.empty()) {
int u = q.front();
q.pop();
inQueue[u] = false;
score[u]++;
int tmp = u;
while (tmp > 0) {
int maskOfBit = tmp & -tmp;
int v = u ^ maskOfBit;
if (score[v] < 2 && !inQueue[v]) {
q.push(v);
inQueue[v] = true;
}
tmp ^= maskOfBit;
}
}
}
int chooseGreedy(int x) {
int needMask = 0;
int res = 0;
for (int i = (21 - 1), _a = (0); i >= _a; i--) {
bool canBitOne = (((x) >> (i)) & 1) || score[needMask | (1LL << (i))] >= 2;
if (canBitOne) {
res |= (1LL << (i));
if (!(((x) >> (i)) & 1)) needMask |= (1LL << (i));
}
}
return res;
}
void process(void) {
int res = 0;
for (int i = (n), _a = (1); i >= _a; i--) {
maximize(res, chooseGreedy(a[i]));
addNumber(a[i]);
}
cout << res << endl;
}
int main(void) {
init();
process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const long long INF = (long long)5e18;
const int MOD = 998244353;
int _abs(int x) { return x < 0 ? -x : x; }
int add(int x, int y) {
x += y;
return x >= MOD ? x - MOD : x;
}
int sub(int x, int y) {
x -= y;
return x < 0 ? x + MOD : x;
}
void Add(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
void Sub(int &x, int y) {
x -= y;
if (x < 0) x += MOD;
}
void Mul(int &x, int y) { x = (long long)(x) * (y) % MOD; }
int qpow(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = (long long)(ret) * (x) % MOD;
x = (long long)(x) * (x) % MOD;
y >>= 1;
}
return ret;
}
void checkmin(int &x, int y) {
if (x > y) x = y;
}
void checkmax(int &x, int y) {
if (x < y) x = y;
}
void checkmin(long long &x, long long y) {
if (x > y) x = y;
}
void checkmax(long long &x, long long y) {
if (x < y) x = y;
}
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x * f;
}
const int N = 2200005;
pair<int, int> dp[N];
pair<int, int> merge(pair<int, int> A, pair<int, int> B) {
int t[4];
t[0] = A.first;
t[1] = A.second;
t[2] = B.first;
t[3] = B.second;
sort(t, t + 4);
return make_pair(t[3], t[2]);
}
int n, a[N], m = (1 << 21);
void FWT(pair<int, int> *a, int len) {
for (int h = 1; h < len; h <<= 1) {
for (int i = 0; i < len; i += (h << 1)) {
for (int j = i; j < i + h; j++) a[j] = merge(a[j], a[j + h]);
}
}
}
int main() {
n = read();
for (int i = 0; i < m; i++) dp[i] = make_pair(0, 0);
for (int i = 1; i <= n; i++) {
a[i] = read();
dp[a[i]].second = dp[a[i]].first;
dp[a[i]].first = i;
}
FWT(dp, m);
int ans = 0;
for (int i = 1; i <= n - 2; i++) {
int now = 0, ret = 0;
for (int j = 20; j >= 0; j--) {
int to = now | (1 << j);
if (a[i] >> j & 1) {
ret |= (1 << j);
continue;
}
if (dp[to].second > i) now = to, ret |= (1 << j);
}
checkmax(ans, ret);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void open(const char *s) {}
inline int rd() {
static int x, f;
x = 0;
f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return f > 0 ? x : -x;
}
const int N = 1000100;
int n, ans = 0, a[N], f[1 << 21][21];
void dp(int S, int x) {
if (x > 20) return;
if (f[S][x] > 1) return;
++f[S][x];
dp(S, x + 1);
if (S >> x & 1) dp(S ^ (1 << x), x);
}
int main() {
n = rd();
for (int i = 1; i <= n; i++) a[i] = rd();
for (int i = n; i >= 1; i--) {
int res = 0, t = 0;
for (int j = 20; j >= 0; j--)
if (a[i] >> j & 1)
res |= 1 << j;
else if (f[t | (1 << j)][20] > 1)
t |= 1 << j, res |= 1 << j;
if (i <= n - 2) ans = max(ans, res);
dp(a[i], 0);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXB = 21;
const int MAXN = 1 << MAXB;
int n, f[MAXN], a[MAXN][2];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &f[i]);
}
for (int i = 0; i < MAXN; ++i) {
a[i][0] = -1;
a[i][1] = -1;
}
for (int i = n; i >= 1; --i) {
if (a[f[i]][0] == -1) {
a[f[i]][0] = i;
continue;
}
if (a[f[i]][1] == -1) {
a[f[i]][1] = i;
}
}
for (int x = MAXN - 1; x >= 0; --x) {
vector<int> pos_list;
for (int k = 0; k < 2; ++k) {
if (a[x][k] != -1) {
pos_list.push_back(a[x][k]);
}
}
for (int i = 0; i < MAXB; ++i) {
if ((x >> i & 1) == 1) {
continue;
}
int nx = x | (1 << i);
for (int k = 0; k < 2; ++k) {
if (a[nx][k] != -1) {
pos_list.push_back(a[nx][k]);
}
}
}
sort(pos_list.begin(), pos_list.end(), greater<int>());
pos_list.resize(unique(pos_list.begin(), pos_list.end()) -
pos_list.begin());
a[x][0] = a[x][1] = -1;
for (int i = 0; i < 2 && i < (int)pos_list.size(); ++i) {
a[x][i] = pos_list[i];
}
}
int ans = 0;
for (int i = 1; i <= n - 2; ++i) {
int val = f[i];
int mask = 0;
for (int k = MAXB - 1; k >= 0; --k) {
if ((val >> k & 1) == 1) {
continue;
}
int nmask = mask | (1 << k);
if (a[nmask][1] > i) {
mask = nmask;
}
}
ans = max(ans, val | mask);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
template <class T>
T Min(const T &a, const T &b) {
return a < b ? a : b;
}
template <class T>
T Max(const T &a, const T &b) {
return a > b ? a : b;
}
template <class T>
bool Chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
bool Chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
struct fast_input {
static const int L = 1 << 15 | 1;
char buf[L], *l, *r;
fast_input() { l = r = buf; }
void Next(char &c) {
if (l == r) r = (l = buf) + fread(buf, 1, L, stdin);
c = l == r ? (char)EOF : *l++;
}
template <class T>
void operator()(T &x) {
char c, f = 0;
for (Next(c); !isdigit(c); Next(c))
if (c == '-') f = 1;
for (x = 0; isdigit(c); Next(c)) x = x * 10 + c - '0';
if (f) x = -x;
}
} input;
const int N = 1 << 21 | 1;
const int B = 21;
int a[N], f[N], g[N], ans, n;
void update(int x, int y) {
if (f[x] == y || g[x] == y) return;
if (!f[x])
f[x] = y;
else if (f[x] > y)
Chkmax(g[x], y);
else
g[x] = f[x], f[x] = y;
}
void udf(int x, int y) {
if (f[x]) update(y, f[x]);
if (g[x]) update(y, g[x]);
}
int main() {
int x, y, z, now;
input(n);
for (int i = (1), i_end = (n); i <= i_end; ++i) input(a[i]), update(a[i], i);
for (int i = ((1 << B) - 1), i_end = (1); i >= i_end; --i)
for (int j = (0), j_end = (B); j < j_end; ++j)
if (i >> j & 1) udf(i, i ^ (1 << j));
for (int i = (1), i_end = (n - 2); i <= i_end; ++i) {
x = a[i] ^ ((1 << B) - 1), y = 0;
for (int j = (B - 1), j_end = (0); j >= j_end; --j)
if (x >> j & 1 && g[y | (1 << j)] > i) y |= 1 << j;
Chkmax(ans, y | a[i]);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[1000005];
pair<int, int> dp[1 << 21];
void add(int mask, int ind) {
if (dp[mask].first == ind || dp[mask].second == ind) return;
if (dp[mask].first < ind) {
dp[mask].second = dp[mask].first;
dp[mask].first = ind;
} else if (dp[mask].second < ind)
dp[mask].second = ind;
}
void merge(int a, int b) {
if (dp[b].first != -1) add(a, dp[b].first);
if (dp[b].second != -1) add(a, dp[b].second);
}
int main() {
memset(dp, -1, sizeof(dp));
int n, mx = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
mx = max(mx, (int)log2(arr[i]));
add(arr[i], i);
}
int ans = 0;
mx++;
for (int i = 0; i < mx; i++)
for (int j = 0; j < (1 << mx); j++)
if ((j >> i) & 1) merge(j ^ (1 << i), j);
for (int i = 1; i <= n; i++) {
int now = 0, cur = (1 << mx) - 1 - arr[i];
for (int j = mx - 1; j >= 0; j--) {
if (((cur >> j) & 1) && dp[now ^ (1 << j)].second > i) now ^= (1 << j);
}
if (dp[now].second > i) ans = max(ans, now ^ arr[i]);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 2e6 + 5;
using namespace std;
int a[N], n, ans, mx;
pair<int, int> f[N];
template <typename T>
inline T read() {
T x = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') w = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * w;
}
void insert(int x, int y) {
if (y > f[x].first)
f[x].second = f[x].first, f[x].first = y;
else if (y > f[x].second)
f[x].second = y;
return;
}
void init() {
for (int i = 1; i <= n; i++) insert(a[i], i);
for (int j = 0; j <= 20; j++)
for (int i = mx; i >= 0; i--)
if (i & (1 << j))
insert(i ^ (1 << j), f[i].first), insert(i ^ (1 << j), f[i].second);
}
int main() {
n = read<int>();
for (int i = 1; i <= n; i++) a[i] = read<int>(), mx = max(mx, a[i]);
init();
for (int x, i = 1; i <= n - 2; i++) {
x = 0;
for (int j = 20; j >= 0; j--) {
if (a[i] & (1 << j)) continue;
if (f[x | (1 << j)].second > i) x |= (1 << j);
}
ans = max(ans, a[i] | x);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vpii = vector<pii>;
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return b > a ? a = b, 1 : 0;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int LG = 21;
const int mxN = 1 << LG;
const int MOD = 1e9 + 7;
const ll infLL = 1e18;
const ld eps = 1e-6;
int n;
int a[mxN];
pii dp[mxN];
void add(pii& x, int y) {
if (x.first == -1) {
x.first = y;
} else if (x.second == -1) {
if (x.first == y) return;
x.second = y;
if (x.first > x.second) swap(x.first, x.second);
} else {
if (x.second < y) {
x.first = x.second;
x.second = y;
} else if (x.first < y && x.second != y) {
x.first = y;
}
}
}
void comb(int Y, int X) {
if (dp[X].first != -1) add(dp[Y], dp[X].first);
if (dp[X].second != -1) add(dp[Y], dp[X].second);
}
int ans = 0;
int main() {
cin.tie(0)->sync_with_stdio(0);
fill(dp, dp + mxN, pii{-1, -1});
cin >> n;
for (auto i = (0); i < (n); i++) cin >> a[i], add(dp[a[i]], i);
for (auto i = (0); i < (LG); i++) {
for (auto j = (0); j < (1 << LG); j++) {
if (j & (1 << i)) comb(j ^ (1 << i), j);
}
}
for (auto i = (0); i < (n); i++) {
int cur = ((1 << LG) - 1) ^ a[i];
int res = 0;
for (auto j = (LG)-1; j >= (0); j--) {
if ((1 << j) & cur) {
if (dp[res ^ (1 << j)].second != -1 && dp[res ^ (1 << j)].first > i)
res ^= 1 << j;
}
}
if (dp[res].second != -1 && dp[res].first > i) ckmax(ans, a[i] ^ res);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[1111111], cnt[2222222], ans, msk, cur;
bool vis[2222222];
vector<int> v;
void add(int x) {
vis[x] = 1;
v.push_back(x);
if (cnt[x] >= 2) return;
cnt[x]++;
for (int i = 0; i <= 20; i++) {
if (x & (1 << i)) {
if ((cnt[x ^ (1 << i)] < 2) && !vis[x ^ (1 << i)]) add(x ^ (1 << i));
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
add(a[n]);
for (int i = 0; i < v.size(); i++) vis[v[i]] = 0;
v.clear();
add(a[n - 1]);
for (int i = n - 2; i >= 1; i--) {
cur = a[i];
msk = 0;
for (int j = 20; j >= 0; j--) {
if (a[i] & (1 << j)) continue;
msk ^= (1 << j);
if (cnt[msk] >= 2)
cur += (1 << j);
else
msk ^= (1 << j);
}
ans = max(ans, cur);
for (int i = 0; i < v.size(); i++) vis[v[i]] = 0;
v.clear();
add(a[i]);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rand(int l, int r) {
uniform_int_distribution<int> uid(l, r);
return uid(rng);
}
const int mod = 1e9 + 7;
long long pwr(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
const int N = 1e6 + 5;
int dp[1 << 21][2];
int a[N];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int mask = 0; mask <= (1 << 21) - 1; mask++) {
dp[mask][0] = dp[mask][1] = -1;
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = n; i >= 1; i--) {
if (dp[a[i]][0] == -1)
dp[a[i]][0] = i;
else if (dp[a[i]][1] == -1)
dp[a[i]][1] = i;
}
for (int k = 0; k <= 20; k++) {
for (int mask = (1 << 21) - 1; mask >= 0; mask--) {
if (!((mask >> k) & 1)) {
for (int j = 0; j <= 1; j++) {
int mmask = mask ^ (1 << k);
int val = dp[mmask][j];
for (int k = 0; k <= 1; k++) {
if (dp[mask][k] < val) {
swap(val, dp[mask][k]);
}
}
}
}
}
}
int ans = 0;
for (int i = 1; i <= n - 2; i++) {
int now = 0;
for (int k = 20; k >= 0; k--) {
if (a[i] & (1 << k)) continue;
int nnow = now ^ (1 << k);
if (dp[nnow][1] > i) now = nnow;
}
ans = max(ans, (now ^ a[i]));
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 3e6 + 10;
const int mod = 998244353;
using namespace std;
pair<int, int> dp[N];
int a[N];
void up(int x, int p) {
if (dp[x].first == -1)
dp[x].first = p;
else if (dp[x].second == -1) {
if (dp[x].first == p) return;
dp[x].second = p;
} else {
if (dp[x].first < dp[x].second) swap(dp[x].first, dp[x].second);
if (p > dp[x].first)
dp[x].second = dp[x].first, dp[x].first = p;
else if (p > dp[x].second && p != dp[x].first)
dp[x].second = p;
}
}
void merge(int m1, int m2) {
if (~dp[m1].first) up(m2, dp[m1].first);
if (~dp[m1].second) up(m2, dp[m1].second);
}
int main() {
int n;
scanf("%d", &n);
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = n; i >= 1; --i)
if (dp[a[i]].first == -1)
dp[a[i]].first = i;
else if (dp[a[i]].second == -1)
dp[a[i]].second = i;
for (int j = 0; j < 21; ++j)
for (int i = 0; i < (1 << 21); ++i)
if ((i >> j) & 1) {
merge(i, i ^ (1 << j));
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
int cur = (1 << 21) - 1 - a[i];
int opt = 0;
for (int j = 20; j >= 0; --j)
if ((cur >> j) & 1) {
if (dp[opt ^ (1 << j)].second > i) opt ^= (1 << j);
}
if (dp[opt].second > i) ans = max(ans, a[i] | opt);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline pair<int, int> merge(pair<int, int> x, pair<int, int> y) {
int u = max(x.first, y.first), v = max(x.second, y.second);
if (x.first < u) v = max(x.first, v);
if (y.first < u) v = max(y.first, v);
return pair<int, int>(u, v);
}
pair<int, int> a[1 << 21];
void fwt1(int len) {
for (int i = 1; i < len; i <<= 1)
for (int j = 0; j < len; j++)
if (j & i) a[j ^ i] = merge(a[j ^ i], a[j]);
}
int b[1 << 21];
void fwt2(int len) {
for (int i = 1; i < len; i <<= 1)
for (int j = 0; j < len; j++)
if (j & i) b[j ^ i] = max(b[j ^ i], b[j]);
}
int num[1000005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
a[num[i]] = merge(a[num[i]], pair<int, int>(i, 0));
}
fwt1(1 << 21);
for (int i = 0; i < (1 << 21); i++) b[i] = a[i].second;
int ans = 0;
for (int i = 1; i < n - 1; i++) {
int s = num[i];
for (int j = 20; j >= 0; j--)
if (!((s >> j) & 1) && b[s ^ num[i] ^ (1 << j)] > i) s ^= (1 << j);
ans = max(ans, s);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int inf = 0x3f3f3f3f;
inline long long read() {
register long long x = 0, f = 1;
register char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
return x * f;
}
void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
void wri(long long x) { write(x), putchar(' '); }
void writeln(long long x) { write(x), putchar('\n'); }
const int mod = 998244353;
const int maxn = 1 << 19 | 233;
inline int qpow(int a, int b) {
int ans = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) ans = 1ll * ans * a % mod;
return ans;
}
long long a[1 << 22], mx[1 << 22], mn[1 << 22], n, m, ans;
int main() {
n = read();
for (register int i = (1); i <= int(n); ++i) {
a[i] = read();
mn[a[i]] = mx[a[i]];
mx[a[i]] = i;
}
for (register int i = (0); i < int(22); ++i) {
for (register int j = (0); j < int(1 << 22); ++j) {
if ((j >> i & 1) == 0) {
if (mx[j] <= mx[j | (1 << i)]) {
mn[j] = mx[j], mx[j] = mx[j | (1 << i)];
if (mn[j | (1 << i)] > mn[j]) mn[j] = mn[j | (1 << i)];
} else if (mx[j | (1 << i)] >= mn[j])
mn[j] = mx[j | (1 << i)];
}
}
}
for (register int i = (1); i <= int(n - 2); ++i) {
long long res = 0;
for (register int j = (21); j >= int(0); --j)
if ((a[i] >> j & 1) == 0)
if (mn[res | (1 << j)] > i) res |= (1 << j);
ans = max(ans, res | a[i]);
}
writeln(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
inline int read() {
int sum = 0, fg = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') fg = -1;
for (; isdigit(c); c = getchar()) sum = (sum << 3) + (sum << 1) + (c ^ 0x30);
return fg * sum;
}
const int maxn = 1e6 + 10;
const int maxm = 2e6 + 10;
int n, a[maxn], c[maxm];
inline void ins(int x, int p) {
if (c[x] >= 2) return;
if (p == -1) return void(++c[x]);
ins(x, p - 1);
if ((x >> p) & 1) ins(x ^ (1 << p), p - 1);
}
inline int que(int x) {
int res = 0, y = 0;
for (int i = 20; ~i; i--)
if ((x >> i) & 1)
res |= 1 << i;
else if (c[y | (1 << i)] >= 2)
res |= 1 << i, y |= 1 << i;
return res;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
int ans = 0;
for (int i = n; i >= 1; i--) {
if (i + 2 <= n) chkmax(ans, que(a[i]));
ins(a[i], 20);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 21) + 1;
int n, res, a[N], c[N], have[N];
void add(int mask, int id) {
if (c[mask] > 1 || have[mask] == id) return;
c[mask]++;
have[mask] = id;
for (int j = 0, ggd = 21; j < ggd; j++)
if (mask & (1 << j)) add(mask ^ (1 << j), id);
}
int get(int x) {
int mask = 0;
for (int i = 21 - 1; i >= 0; i--) {
if (x & (1 << i)) continue;
int new_mask = mask | (1 << i);
if (c[new_mask] > 1) mask = new_mask;
}
return mask;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0, ggd = n; i < ggd; i++) cin >> a[i];
memset(have, -1, sizeof(have));
for (int i = n - 1; i >= 0; i--) {
if (n - i >= 3) res = max(res, a[i] | get(a[i]));
add(a[i], i);
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
int ch = 0, f = 0;
x = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = 1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
if (f) x = -x;
}
vector<int> d;
int cnt[2000005], a[2000005], vis[2000005], n, ans;
inline void gao(int s) {
if (cnt[s] == 2 || vis[s]) return;
vis[s] = 1, cnt[s]++, d.push_back(s);
for (int i = 0; i <= 20; i++)
if ((1 << i) & s) gao(s ^ (1 << i));
}
int main() {
read(n);
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = n; i >= 1; i--) {
int s = 0;
for (int j = 20; ~j; j--)
if ((!((1 << j) & a[i])) && cnt[s ^ (1 << j)] == 2) s |= 1 << j;
if (i + 2 <= n) ans = max(ans, a[i] | s);
gao(a[i]);
for (int j = 0; j < (int)d.size(); j++) vis[d[j]] = 0;
d.clear();
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxx = 1e6 + 10;
vector<int> a[(1 << 21)];
int b[maxx];
bool cmp(int x, int y) { return x > y; }
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
b[i] = x;
}
for (int i = n; i; i--) {
if (a[b[i]].size() < 2) a[b[i]].push_back(i);
}
for (int j = 0; j <= 21; j++) {
for (int i = 2000000; i >= 0; i--) {
if (i & (1 << j)) continue;
if (i + (1 << j) <= 2000000) {
for (auto x : a[i + (1 << j)]) {
a[i].push_back(x);
}
}
sort(a[i].begin(), a[i].end(), cmp);
while (a[i].size() > 2) a[i].pop_back();
}
}
int ans = 0;
for (int i = n - 2; i; i--) {
int x = 0;
for (int j = 20; j >= 0; j--) {
if (b[i] & (1 << j)) {
;
} else {
x += (1 << j);
if (a[x].size() < 2 || a[x][1] <= i) {
x -= (1 << j);
}
}
}
ans = max(ans, (b[i] | x));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
void ins(pair<int, int> &p, int x) {
if (x == -1 || p.first == x || p.second == x) return;
if (x > p.first) swap(p.first, x);
if (x > p.second) swap(p.second, x);
}
const int K = 21;
int s[1 << K];
void mark(int m) {
if (s[m]) return;
s[m] = 1;
for (int i = 0; i < (int)(K); ++i)
if ((m >> i) & 1) mark(m ^ (1 << i));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < (int)(n); ++i) cin >> a[i];
vector<pair<int, int> > occ(1 << K, {-1, -1});
for (int i = 0; i < (int)(n); ++i) ins(occ[a[i]], i);
for (int i = (int)(1 << K) - 1; i >= 0; --i)
for (int j = 0; j < (int)(K); ++j)
if ((i >> j) & 1) {
pair<int, int> &p = occ[i], &q = occ[i ^ (1 << j)];
ins(q, p.first);
ins(q, p.second);
}
vector<vector<int> > q(n);
for (int i = 0; i < (int)(1 << K); ++i)
if (occ[i].second != -1) {
q[occ[i].second].push_back(i);
}
int ans = 0;
for (int i = 0; i < (int)(n); ++i) {
for (int x : q[i]) {
int mask = 0;
for (int j = (int)(K)-1; j >= 0; --j) {
if ((x >> j) & 1) continue;
if (s[mask | (1 << j)]) mask |= 1 << j;
}
uax(ans, x + mask);
}
mark(a[i]);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename T1>
T maxs(T& a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T mins(T& a, T1 b) {
if (b < a) a = b;
return a;
}
const long long N = (1 << 21);
const long long M = N - 1;
pair<long long, long long> dp[N];
long long solve() {
long long n;
cin >> n;
vector<long long> a(n + 1);
auto add = [&](long long mask, long long j) {
if (dp[mask].first == -1)
dp[mask].first = j;
else if (dp[mask].second == -1) {
dp[mask].second = j;
if (dp[mask].second < dp[mask].first)
swap(dp[mask].first, dp[mask].second);
} else if (dp[mask].second < j) {
dp[mask].first = dp[mask].second;
dp[mask].second = j;
} else if (dp[mask].first < j && j != dp[mask].second) {
dp[mask].first = j;
}
};
for (long long i = 1; i < n + 1; i++) {
cin >> a[i];
add(a[i], i);
}
for (long long i = 0; i < 21; i++) {
for (long long mask = 0; mask < N; mask++) {
if ((mask) & (1 << i)) {
if (dp[mask].first != -1) add(mask ^ (1 << i), dp[mask].first);
if (dp[mask].second != -1) add(mask ^ (1 << i), dp[mask].second);
}
}
}
long long ans = 0;
for (long long i = 1; i < n + 1; i++) {
long long rev_mask = M - a[i];
long long best = 0;
for (long long j = 20; j >= 0; j--) {
if (rev_mask & (1 << j)) {
if (dp[best ^ (1 << j)].second != -1 && dp[best ^ (1 << j)].first > i) {
best ^= (1 << j);
}
}
}
if (i + 2 <= n) maxs(ans, a[i] + best);
}
cout << ans << "\n";
return 0;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[1 << 21];
void upd(int x, int k) {
if (A[x | k] == 2) return;
if (x == 0) {
A[k]++;
return;
}
upd(x & (x - 1), k | (x & (-x)));
upd(x & (x - 1), k);
}
int a[1 << 21];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[n + 1 - i];
int ans = 0;
int();
for (int i = 1; i <= n; i++) {
int now = 0;
for (int j = 20; j >= 0; j--) {
if ((a[i] & (1 << j)) == 0) {
now |= A[now | (1 << j)] == 2 ? 1 << j : 0;
}
}
if (i >= 3) ans = max(ans, a[i] | now);
upd(a[i], 0);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("AAtest.in.txt");
const int c = (1 << 21) + 5;
int n, jad[1000005], a[c], vas;
void leia(int x) {
int y = 0, m = 21;
while (m--)
if (!((x >> m) & 1) and a[(1 << m) + y] >= 2) y += 1 << m;
vas = max(vas, x | y);
}
void pane(int x, int k) {
if (a[x]++ >= 2) return;
do {
if (x >> k & 1) pane(x ^ 1 << k, k + 1);
} while (++k < 21);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n;
for (int(i) = (0); ((i)) < ((n)); ((i))++) cin >> jad[i];
for (int i = n - 1; i >= 0; i--) {
if (i < n - 2) leia(jad[i]);
pane(jad[i], 0);
}
cout << vas;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1e9;
const long long inf = (long long)1e18;
const long double eps = (long double)1e-6;
const long long mod = (long long)1e9 + 7;
const long long MAXN = 1001;
const long long MAXLOG = 19;
const long long maxlen = (long long)1e5;
const long long asci = (long long)256;
const long long block = 707;
template <class T>
istream &operator>>(istream &in, vector<T> &arr) {
for (T &cnt : arr) {
in >> cnt;
}
return in;
};
int cnt[1 << 21];
int used[1 << 21];
void dfs(int n, int c) {
cnt[n]++;
used[n] = c;
for (int i = 0; i <= 20; ++i) {
if (n & (1 << i) && cnt[n ^ (1 << i)] < 2 && used[n ^ (1 << i)] != c)
dfs(n ^ (1 << i), c);
}
}
void solve() {
int n;
cin >> n;
vector<long long> a(n);
cin >> a;
int ans = 0;
int c = 1;
for (int i = n - 1; i >= 0; --i) {
int res = 0;
for (int j = 20; j >= 0; --j) {
if (!(a[i] & (1 << j))) {
if (cnt[res | (1 << j)] == 2) res |= 1 << j;
}
}
ans = max(ans, res | (int)a[i]);
dfs(a[i], c);
c++;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000005], n, dp[1 << 21][21];
void upd(int num, int b = 20) {
if (b < 0 || dp[num][b] > 1) return;
++dp[num][b];
upd(num, b - 1);
if (num >> b & 1) upd(num ^ (1 << b), b);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; cin >> a[i++])
;
int ans = 0;
for (int i = n; i > 0; upd(a[i--])) {
int now = 0, req = 0;
for (int b = 21; b--;)
if (a[i] >> b & 1)
now |= 1 << b;
else if (dp[req | (1 << b)][0] > 1)
now |= 1 << b, req |= 1 << b;
if (i < n - 1) ans = max(ans, now);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1e6 + 50;
const int maxa = 2e6 + 50;
int n, a[maxn];
pair<int, int> dp[maxa];
void updata(int x, int pos) {
if (dp[x].first < pos) {
dp[x].second = dp[x].first;
dp[x].first = pos;
} else if (dp[x].second < pos && pos != dp[x].first)
dp[x].second = pos;
}
void get_dp() {
for (int i = 0; i <= 20; i++)
for (int x = 0; x <= maxa - 1; x++) {
if (((x >> i) & 1) == 1) {
updata(x ^ (1 << i), dp[x].first);
updata(x ^ (1 << i), dp[x].second);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
updata(a[i], i);
}
get_dp();
int ans = 0;
for (int i = 1; i <= n - 2; i++) {
int w = 0;
for (int j = 20; j >= 0; j--) {
if (((a[i] >> j) & 1) == 0 && dp[w | (1 << j)].first > i &&
dp[w | (1 << j)].second > i)
w = w | (1 << j);
}
ans = max(ans, a[i] | w);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
template <class T>
inline void read(T &res) {
res = 0;
bool bo = 0;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
if (c == '-')
bo = 1;
else
res = c - 48;
while ((c = getchar()) >= '0' && c <= '9')
res = (res << 3) + (res << 1) + (c - 48);
if (bo) res = ~res + 1;
}
const int N = 1e6 + 5, M = 3e6 + 5;
int n, a[N], ans;
struct elem {
int mx, cmx;
friend inline elem operator+(elem a, elem b) {
return (elem){std::max(a.mx, b.mx),
std::min(std::max(a.mx, b.cmx), std::max(a.cmx, b.mx))};
}
} f[M];
int main() {
read(n);
for (int i = 1; i <= n; i++) {
read(a[i]);
if (i > f[a[i]].mx)
f[a[i]].cmx = f[a[i]].mx, f[a[i]].mx = i;
else if (i > f[a[i]].cmx)
f[a[i]].cmx = i;
}
for (int k = 0; k <= 20; k++)
for (int i = 0; i < 2097152; i++)
if (!((i >> k) & 1)) f[i] = f[i] + f[i | (1 << k)];
for (int i = n; i >= 1; i--) {
int res = 0, S = 0;
for (int j = 20; j >= 0; j--)
if ((a[i] >> j) & 1)
res |= 1 << j;
else if (f[S | (1 << j)].cmx > i)
S |= 1 << j, res |= 1 << j;
if (i <= n - 2 && res > ans) ans = res;
}
return std::cout << ans << std::endl, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[2100000];
pair<int, int> dp[2100000];
int id[2100000];
int id2[2100000];
pair<int, int> R(pair<int, int> A, pair<int, int> B) {
pair<int, int> res = A;
if (A.second > B.second) {
res.first = max(res.first, B.second);
} else {
res = B;
res.first = max(res.first, A.second);
}
return res;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = n; i >= 1; i--) {
if (id[a[i]] == 0) {
id[a[i]] = i;
} else if (id2[a[i]] == 0) {
id2[a[i]] = i;
}
}
int N = 21;
int tar = (1 << N) - 1;
for (int i = 0; i < (1 << N); ++i) dp[tar ^ i] = make_pair(id2[i], id[i]);
for (int i = 0; i < N; ++i)
for (int mask = 0; mask < (1 << N); ++mask) {
if (mask & (1 << i)) dp[mask] = R(dp[mask], dp[mask ^ (1 << i)]);
}
int maxx = 0;
for (int i = 1; i <= n - 2; i++) {
int x = a[i];
int rem = tar ^ x;
pair<int, int> ans = make_pair(0, 0);
int temp = 0;
for (int j = N - 1; j >= 0; j--) {
if (rem & (1 << j)) {
temp |= (1 << j);
ans = dp[tar ^ temp];
if (ans.first < i) {
temp -= (1 << j);
}
}
}
maxx = max(maxx, temp ^ a[i]);
}
cout << maxx << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[1000006], ans, bits;
pair<int, int> dp[1 << 21];
void add(int mask, int w) {
if (dp[mask].first == -1)
dp[mask].first = w;
else if (dp[mask].second == -1) {
if (dp[mask].first == w) return;
dp[mask].second = w;
if (dp[mask].first > dp[mask].second) swap(dp[mask].first, dp[mask].second);
} else {
if (dp[mask].second < w) {
dp[mask].first = dp[mask].second;
dp[mask].second = w;
} else if (dp[mask].first < w and dp[mask].second != w)
dp[mask].first = w;
}
}
void merge(int m1, int m2) {
if (dp[m2].first != -1) add(m1, dp[m2].first);
if (dp[m2].second != -1) add(m1, dp[m2].second);
}
void solve() {
memset(dp, -1, sizeof dp);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
add(a[i], i);
bits = max((int)log2(a[i]), bits);
}
bits++;
for (int i = 0; i < bits; i++) {
for (int mask = 0; mask < 1 << bits; mask++) {
if (mask & (1 << i)) {
merge(mask ^ (1 << i), mask);
}
}
}
for (int i = 0; i < n; i++) {
int cur = (1 << bits) - 1 - a[i];
int opt = 0;
for (int j = bits - 1; j >= 0; j--) {
if ((cur >> j) & 1) {
if (dp[opt ^ (1 << j)].second != -1 and dp[opt ^ (1 << j)].first > i) {
opt ^= (1 << j);
}
}
}
if (dp[opt].second != -1 and dp[opt].first > i) ans = max(ans, a[i] ^ opt);
}
cout << ans << '\n';
}
signed main() {
ios::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;
int A[1 << 21];
void upd(int x, int k) {
if (A[x | k] == 2) return;
if (x == 0) {
A[k]++;
return;
}
upd(x & (x - 1), k | (x & (-x)));
upd(x & (x - 1), k);
}
int a[1 << 21];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[n + 1 - i];
int ans = 0;
int();
for (int i = 1; i <= n; i++) {
int now = 0;
for (int j = 20; j >= 0; j--) {
if ((a[i] & (1 << j)) == 0) {
now |= A[now | (1 << j)] == 2 ? 1 << j : 0;
}
}
if (i >= 3) ans = max(ans, a[i] | now);
upd(a[i], 0);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4000005;
int n;
int a[maxn];
struct nod {
int ans1, ans2;
} dp[maxn];
inline int read() {
int ret = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -f;
ch = getchar();
}
while (isdigit(ch)) {
ret = ret * 10 + ch - '0';
ch = getchar();
}
return ret * f;
}
inline void insert(int x, int p) {
if (x > dp[p].ans1) {
dp[p].ans2 = dp[p].ans1;
dp[p].ans1 = x;
return;
}
if (x > dp[p].ans2) dp[p].ans2 = x;
}
void scan() {
n = read();
for (int k = 1; k <= n; k++) a[k] = read();
}
void prework() {
for (int k = 1; k <= n; k++) insert(k, a[k]);
for (int j = 0; j <= 21; j++) {
for (int i = maxn - 1; i >= 0; i--)
if (i & (1 << j)) {
insert(dp[i].ans1, i ^ (1 << j));
insert(dp[i].ans2, i ^ (1 << j));
}
}
}
void solve() {
int ans = 0;
for (int k = 1; k <= n - 2; k++) {
int now = 0;
for (int j = 21; j >= 0; j--)
if (!(a[k] & (1 << j))) {
int p = (now | (1 << j));
if (dp[p].ans2 > k) now = p;
}
ans = max(ans, (now | a[k]));
}
printf("%d\n", ans);
}
signed main() {
scan();
prework();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 1000000, B = 20;
int fr[1 << B + 1], x[N];
void ad(int x, int j = 0) {
if (fr[x] == 2) return;
++fr[x];
for (int i = j; i < (int)(B + 1); ++i)
if (x >> i & 1) ad(x ^ 1 << i, i + 1);
}
int qu(int x) {
int an = 0;
for (int i = B; i >= 0; --i)
if (!(x >> i & 1) && fr[an ^ 1 << i] == 2) an ^= 1 << i;
return an ^ x;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < (int)(n); ++i) scanf("%d", x + i);
int an = 0;
for (int i = n - 1; i >= 0; --i) {
if (i + 2 < n) an = max(an, qu(x[i]));
ad(x[i]);
}
printf("%d\n", an);
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[1 << 21];
void add(int x, int bit) {
if (cnt[x] >= 2) return;
if (bit < 0) {
cnt[x]++;
return;
}
add(x, bit - 1);
if (x >> bit & 1) add(x ^ 1 << bit, bit - 1);
}
int get(int x) {
int y = 0;
for (int i = 20; i >= 0; i--)
if (x >> i & 1 ^ 1)
if (cnt[y | 1 << i] >= 2) y |= 1 << i;
return x | y;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, a[1000100];
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (i + 3 <= n) ans = max(ans, get(a[i]));
add(a[i], 20);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
int n, a[N], t[1 << 21];
void insert(int x, int d) {
if (t[x] == 2) return;
if (d == -1) {
t[x]++;
return;
}
insert(x, d - 1);
if (x & (1 << d)) insert(x ^ (1 << d), d - 1);
}
int query(int x) {
int ans = 0;
for (int i = 20; i >= 0; i--)
if ((x & (1 << i)) == 0 && t[ans | (1 << i)] == 2) ans |= 1 << i;
return ans | x;
}
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--) {
if (i <= n - 2) ans = max(ans, query(a[i]));
insert(a[i], 20);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("AAtest.in.txt");
const int c = (1 << 21) + 5;
int n, jad[1000005], a[c], vas;
void leia(int x) {
int y = 0, m = 21;
while (m--)
if (!((x >> m) & 1) and a[(1 << m) + y] == 2) y += 1 << m;
vas = max(vas, x | y);
}
void pane(int x, int k) {
if (a[x] == 2) return;
a[x]++;
do {
if (x >> k & 1) pane(x ^ 1 << k, k + 1);
} while (++k < 21);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n;
for (int(i) = (0); ((i)) < ((n)); ((i))++) cin >> jad[i];
for (int i = n - 1; i >= 0; i--) {
if (i < n - 2) leia(jad[i]);
pane(jad[i], 0);
}
cout << vas;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1 << 21], a[1001000];
void update(int x, int w) {
if (dp[x] >= 2) return;
if (w == -1) {
dp[x]++;
return;
}
update(x, w - 1);
if ((x & (1 << w)) != 0) {
update(x - (1 << w), w - 1);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int ans = 0;
for (int i = n; i > 0; i--) {
int res = a[i];
int now = 0;
for (int j = 20; j >= 0; j--) {
if (dp[now | (1 << j)] >= 2 && (a[i] & (1 << j)) == 0) {
now = now + (1 << j);
res = res + (1 << j);
}
}
if (i <= n - 2) ans = max(ans, res);
update(a[i], 20);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int d[3 * 1000001], v1[3 * 1000001], v2[3 * 1000001], a[1000001], i, n, tt, tt2,
kq;
void BFS1(int s, int k) {
queue<int> q;
if (v1[s] == 0) {
q.push(s);
v1[s] = k;
}
while (q.size() > 0) {
int u = q.front();
q.pop();
for (int i = 0; i <= 21; i++)
if ((u >> i) & 1) {
int v = u - (1 << i);
if (v1[v] == 0) {
q.push(v);
v1[v] = k;
}
}
}
}
void BFS2(int s, int k) {
queue<int> q;
if (v2[s] > 0) return;
if (d[s] == 0 || d[s] > k) {
q.push(s);
if (d[s] == 0)
d[s] = k;
else
v2[s] = k;
}
while (q.size() > 0) {
int u = q.front();
q.pop();
for (int i = 0; i <= 21; i++)
if ((u >> i) & 1) {
int v = u - (1 << i);
if (v2[v] > 0) continue;
if (d[v] == 0 || d[v] > k) {
q.push(v);
if (d[v] == 0)
d[v] = k;
else
v2[v] = k;
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) BFS1(a[i], i);
for (i = n; i >= 1; i--) BFS2(a[i], i);
for (tt = 0; tt <= 2000000; tt++) {
tt2 = 0;
if (v2[tt] == 0) continue;
for (i = 21; i >= 0; i--) {
if ((tt >> i) & 1) continue;
if (v1[tt2 | (1 << i)] < v2[tt] && v1[tt2 | (1 << i)] > 0)
tt2 |= (1 << i);
}
kq = max(kq, tt | tt2);
}
cout << kq;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 22;
const int mod = 1e9 + 7;
int read() {
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 << 1) + (x << 3) + c - '0', c = getchar();
return x * f;
}
pair<int, int> dp[N];
void add(int x, int pos) {
if (pos > dp[x].first) {
dp[x].second = dp[x].first;
dp[x].first = pos;
} else if (pos > dp[x].second)
dp[x].second = pos;
return;
}
int a[N];
int main() {
int n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
add(a[i], i);
}
for (int i = 0; i < 22; i++) {
for (int j = 0; j < N; j++)
if (j & (1 << i)) {
add(j ^ (1 << i), dp[j].first);
add(j ^ (1 << i), dp[j].second);
}
}
int ans = 0;
for (int i = 1; i <= n - 2; i++) {
int tmp = 0;
for (int j = 21; j >= 0; j--) {
if ((1 << j) & a[i]) continue;
if (dp[tmp | (1 << j)].second > i) tmp |= (1 << j);
}
ans = max(ans, tmp | a[i]);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long P = 1e9 + 7;
const int N = 2e6 + 5;
const long long INF = 1e16;
const double pi = acos(-1);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n, cnt[N], ans, a[N];
void insert(int x, int y) {
if (cnt[x | y] == 2) return;
if (x == 0) {
cnt[y]++;
return;
}
insert(x & x - 1, y | x & -x);
insert(x & x - 1, y);
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); ++i) scanf("%d", a + i);
for (int i = (n); i >= (1); --i) {
if (i + 2 <= n) {
int now = 0;
for (int j = (20); j >= (0); --j)
if (!(a[i] >> j & 1) && cnt[now | 1 << j] == 2) now |= 1 << j;
ans = max(ans, now | a[i]);
}
insert(a[i], 0);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x(0), f(1);
register char c(getchar());
while (c > '9' || c < '0') f = c == '-' ? -1 : 1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - 48, c = getchar();
return f * x;
}
const int N = 2e6 + 10;
int n, a[N], ans, f[N][3], limit, maxn;
void add(int val, int x) {
if (!f[val][1])
f[val][1] = x;
else if (!f[val][2])
f[val][2] = x;
else {
if (f[val][2] < x)
f[val][1] = f[val][2], f[val][2] = x;
else if (f[val][1] < x)
f[val][1] = x;
}
if (f[val][1] > f[val][2] && f[val][2]) swap(f[val][1], f[val][2]);
}
void up(int v, int u) {
if (f[u][1]) add(v, f[u][1]);
if (f[u][2]) add(v, f[u][2]);
}
int main() {
register int i, j;
n = read();
for (i = 1; i <= n; i++) a[i] = read(), maxn = max(maxn, a[i]);
limit = log2(maxn);
maxn = (1 << (limit + 1)) - 1;
for (i = n; i >= 1; i--) add(a[i], i);
for (i = 0; i <= limit; i++)
for (j = 0; j <= maxn; j++)
if (j & (1 << i)) up(j ^ (1 << i), j);
for (i = 1; i <= n; i++) {
int now = 0, nowmax = maxn - a[i];
for (j = limit; j >= 0; j--)
if (nowmax & (1 << j)) {
int to = (now | (1 << j));
if (f[to][1] > i && f[to][2]) now = to;
}
if (f[now][1] > i && f[now][2]) ans = max(ans, a[i] | now);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int f = 1, x = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline long long readll() {
long long f = 1, x = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int MAXN = (1 << 21) + 100;
int n, a[MAXN], b;
pair<int, int> dp[MAXN];
void add(int s, int v) {
if (!dp[s].first)
dp[s].first = v;
else if (!dp[s].second) {
if (v == dp[s].first) return;
dp[s].second = v;
if (dp[s].first < dp[s].second) swap(dp[s].first, dp[s].second);
} else {
if (v > dp[s].first) {
dp[s].second = dp[s].first;
dp[s].first = v;
} else if (v != dp[s].first && v > dp[s].second) {
dp[s].second = v;
}
}
}
void merge(int s1, int s2) {
if (dp[s2].first) add(s1, dp[s2].first);
if (dp[s2].second) add(s1, dp[s2].second);
}
inline int highbit(int x) { return (int)log2(x) + 1; }
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
a[i] = read();
add(a[i], i);
b = max(b, highbit(a[i]));
}
for (int i = 0; i < b; ++i) {
for (int s = 0; s < (1 << b); ++s) {
if (s & (1 << i)) {
merge(s ^ (1 << i), s);
}
}
}
int ans = 0;
for (int i = 1; i <= n - 2; ++i) {
int goal = (1 << b) - 1 - a[i], opt = 0;
for (int j = b - 1; j >= 0; --j) {
if (goal & (1 << j)) {
if (dp[opt ^ (1 << j)].second > i) {
opt ^= (1 << j);
}
}
}
ans = max(ans, a[i] ^ opt);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1 << 21], idx[1 << 21];
int f[1 << 21], g[1 << 21];
void upd(int i, int j) {
int v[4] = {f[i], g[i], f[j], g[j]}, m;
sort(v, v + 4), m = unique(v, v + 4) - v;
if (m == 1)
f[i] = v[0];
else
f[i] = v[m - 2], g[i] = v[m - 1];
}
int main() {
int n, ret = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i), idx[i] = i;
sort(idx + 1, idx + n + 1,
[](int i, int j) { return (a[i] < a[j] && (a[i] == a[j] && i > j)); });
for (int j = 1, i, m; j <= n;) {
m = a[idx[i = j]];
while (j <= n && m == a[idx[j]]) ++j;
if (j - i == 1)
f[m] = idx[i];
else
f[m] = idx[i + 1], g[m] = idx[i];
}
for (int i = 0; i <= 20; ++i) {
for (int mask = (1 << 21) - 1, u = 1 << i; ~mask; --mask) {
if (!(mask & u)) upd(mask, mask ^ u);
}
}
for (int i = 1; i <= n - 2; i++) {
int w = 0, c = a[i];
for (int j = 20, u = 1 << j; ~j; --j, u >>= 1) {
if (!(c & u) && f[w ^ u] > i && g[w ^ u]) w ^= u;
}
ret = max(ret, c ^ w);
}
printf("%d", ret);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 3e6 + 5;
int a[N], cnt[N];
void Insert(int v, int n) {
if (cnt[v] == 2) return;
if (n == -1) {
cnt[v]++;
return;
}
Insert(v, n - 1);
if (v & (1 << n)) Insert(v ^ (1 << n), n - 1);
}
int query(int x) {
int ans = 0;
for (int i = 21; i >= 0; i--)
if (!(x & (1 << i)) && cnt[ans | (1 << i)] == 2) ans |= 1 << i;
return x | ans;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int ans = 0;
for (int i = n; i >= 0; i--) {
if (i <= n - 2) ans = max(ans, query(a[i]));
if (i > 0) Insert(a[i], 21);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e6 + 10;
inline int read() {
char ch = getchar();
int x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) - '0' + ch;
ch = getchar();
}
return x * f;
}
int n, a[N];
int f[N];
void update(int num, int k) {
if (k == -1) {
++f[num];
return;
}
if (f[num] > 1) return;
update(num, k - 1);
if (num >> k & 1) update(num ^ (1 << k), k - 1);
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
int ans = 0;
for (int i = n; i >= 1; i--) {
int res = 0, t = 0;
for (int j = 20; j >= 0; j--) {
if (a[i] >> j & 1)
res |= (1 << j);
else if (f[t | (1 << j)] > 1)
res |= (1 << j), t |= (1 << j);
}
update(a[i], 20);
if (i <= n - 2) ans = max(ans, res);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int nxt() {
int x;
scanf("%d", &x);
return x;
}
const int L = 21;
const int N = 1 << L;
struct Max2 {
int x, y;
Max2() : x(-1), y(-1) {}
void refresh(int z) {
if (z > x) {
y = x;
x = z;
} else if (z > y) {
y = z;
}
}
void refresh(const Max2& ot) {
refresh(ot.x);
refresh(ot.y);
}
};
Max2 d[N];
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n = nxt();
vector<int> a(n);
for (int i = 0; i < n; ++i) {
a[i] = nxt();
}
for (int i = n - 1; i >= 0; --i) {
d[a[i]].refresh(i);
}
for (int j = 0; j < L; ++j) {
for (int i = N - 1; i >= 0; --i) {
if (!(i & (1 << j))) {
d[i].refresh(d[i | (1 << j)]);
}
}
}
int ans = 0;
for (int i = 0; i < n - 2; ++i) {
int x = 0;
for (int j = L - 1; j >= 0; --j) {
if (a[i] & (1 << j)) {
continue;
}
if (d[x | (1 << j)].y > i) {
x |= 1 << j;
}
}
ans = max(ans, a[i] | x);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f;
const int N = 1e6 + 5;
int n, a[N], num[(1 << 21) + 5][25];
inline void solve(int x, int step) {
if (step == 22 || num[x][step] >= 2) return;
num[x][step]++;
solve(x, step + 1);
if (x & (1 << step)) solve(x ^ (1 << step), step);
}
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
int res, tp, ans = 0;
for (int i = n; i >= 1; --i) {
res = 0, tp = 0;
for (int j = 21; j >= 0; --j) {
if ((a[i] >> j) & 1)
res |= (1 << j);
else if (num[tp | (1 << j)][21] >= 2)
res |= (1 << j), tp |= (1 << j);
}
solve(a[i], 0);
if (i <= n - 2) ans = max(ans, res);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
const int N = 1e6 + 5, LG = 21;
int n, a[N], cnt[1 << LG];
void dfs(int mask, int i) {
if (cnt[mask] >= 2 || i == LG) return;
cnt[mask]++;
for (int j = (i); j < (LG); j++) {
if (((mask >> j) & 1) == 1) {
dfs(mask - (1 << j), j + 1);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = (0); i < (n); i++) {
cin >> a[i];
}
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (i <= n - 3) {
int mask = 0;
for (int l = 20; l >= 0; l--) {
if (((a[i] >> l) & 1) == 0 && cnt[mask + (1 << l)] >= 2) {
mask += (1 << l);
}
}
ans = max(ans, a[i] | mask);
}
dfs(a[i], 0);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int prime = 999983;
const int INF = 0x7FFFFFFF;
const long long INFF = 0x7FFFFFFFFFFFFFFF;
const double pi = acos(-1.0);
const double inf = 1e18;
const double eps = 1e-6;
const long long mod = 1e9 + 7;
long long qpow(long long a, long long b) {
long long s = 1;
while (b > 0) {
if (b & 1) s = s * a % mod;
a = a * a % mod;
b >>= 1;
}
return s;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int dr[2][4] = {1, -1, 0, 0, 0, 0, -1, 1};
const int maxn = 1e6 + 10;
int a[maxn];
int dp[1 << 21];
void update(int num, int k, bool flag) {
if (k > 20) return;
if (dp[num] > 1) return;
update(num, k + 1, 1);
if (!flag) dp[num]++;
if (num >> k & 1) update(num ^ (1 << k), k, 0);
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
int ans = 0;
for (int i = n; i >= 1; --i) {
int res = 0;
int t = 0;
for (int j = 20; j >= 0; --j) {
if (a[i] >> j & 1)
res |= 1 << j;
else if (dp[t | (1 << j)] > 1)
res |= 1 << j, t |= 1 << j;
}
update(a[i], 0, 0);
if (i <= n - 2) ans = max(ans, res);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int LOG = 21;
const int N = (1 << LOG);
int n;
int a[N];
pair<int, int> rightMost[N];
void add(int mask, int val) {
if (val > rightMost[mask].second) swap(rightMost[mask].second, val);
if (rightMost[mask].second > rightMost[mask].first)
swap(rightMost[mask].second, rightMost[mask].first);
}
bool check(int res, int keep) {
for (int i = 1; i <= n; i++) {
int mask = (a[i] ^ res) & keep;
if (rightMost[mask].second > i) return 1;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
add(a[i], i);
}
for (int i = 0; i < LOG; i++) {
for (int j = 0; j < N; j++) {
if (j & 1 << i) {
add(j ^ (1 << i), rightMost[j].first);
add(j ^ (1 << i), rightMost[j].second);
}
}
}
int res = 0;
int keep = 0;
for (int i = LOG - 1; i >= 0; i--) {
keep |= (1 << i);
if (check(res | (1 << i), keep)) res |= (1 << i);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 21, M = 1 << 20;
int n, m, ans, a[M], dp[1 << N][N];
void Insert(const int& S, int id) {
if (id == N || dp[S][id] == 2) return;
++dp[S][id];
Insert(S, id + 1);
if (S & 1 << id) Insert(S ^ 1 << id, id);
}
signed main() {
register int i, j, now, right;
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", a + i);
for (i = n; i; --i) {
now = right = 0;
for (j = N - 1; j >= 0; --j) {
if (a[i] & 1 << j)
now |= 1 << j;
else if (dp[right | 1 << j][20] == 2)
now |= 1 << j, right |= 1 << j;
}
Insert(a[i], 0);
if (i <= n - 2 && now > ans) ans = now;
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 21);
int a[maxn];
int n;
int f[2][maxn];
signed main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
f[1][a[i] ^ (maxn - 1)] = f[0][a[i] ^ (maxn - 1)];
f[0][a[i] ^ (maxn - 1)] = i;
}
for (int i = 0; i < 21; i++) {
for (int mask = 0; mask < (1 << 21); mask++) {
if (mask & (1 << i)) {
for (int j = 0; j < 2; j++) {
if (f[j][mask ^ (1 << i)] >= f[0][mask]) {
f[1][mask] = f[0][mask];
f[0][mask] = f[j][mask ^ (1 << i)];
} else if (f[j][mask ^ (1 << i)] >= f[1][mask]) {
f[1][mask] = f[j][mask ^ (1 << i)];
}
}
}
}
}
int ans = 0;
for (int i = 1; i <= n - 2; i++) {
int x = a[i] ^ (maxn - 1);
int cur = 0;
for (int j = 20; j >= 0; j--) {
if (x & (1 << j)) {
cur += (1 << j);
if (f[1][cur ^ (maxn - 1)] <= i) {
cur -= (1 << j);
}
}
}
ans = max(ans, a[i] | cur);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
void fastscan(int &number) {
bool negative = false;
register int c;
number = 0;
c = getchar();
if (c == '-') {
negative = true;
c = getchar();
}
for (; (c > 47 && c < 58); c = getchar()) number = number * 10 + c - 48;
if (negative) number *= -1;
}
pair<int, int> DP[4 * 1000005];
int ar[1000005];
int N;
pair<int, int> mx(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first)
return (pair<int, int>(a.first, max(a.second, b.second)));
else {
if (a.first > b.first)
return (pair<int, int>(a.first, max(a.second, b.first)));
else
return (pair<int, int>(b.first, max(b.second, a.first)));
}
}
int main() {
fastscan(N);
for (int i = 0; i < 4 * 1000005; i++) {
DP[i].first = -1;
DP[i].second = -1;
}
for (int i = 0; i < N; i++) {
fastscan(ar[i]);
DP[ar[i]].second = DP[ar[i]].first;
DP[ar[i]].first = i;
}
for (int i = (1 << 21) - 1; i >= 0; i--) {
for (int j = 0; j < 21; j++) {
if (i & (1 << j)) DP[i ^ (1 << j)] = mx(DP[i ^ (1 << j)], DP[i]);
}
}
int ans = 0;
for (int i = N - 3; i >= 0; i--) {
int sum = 0;
for (int j = 20; j >= 0; j--) {
if ((ar[i] & (1 << j)) == 0 && (DP[sum + (1 << j)].second > i))
sum += (1 << j);
}
ans = max(ans, (sum | ar[i]));
}
cout << ans << endl;
return (0);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC option("arch=native", "tune=native", "no-zero-upper")
#pragma GCC target("avx2")
#pragma GCC optimize("03")
#pragma GCC target("sse4")
using namespace std;
int a[(long long)(4e6 + 5)];
int first[(long long)(4e6 + 5)];
bool mk[(long long)(4e6 + 5)];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
long long res = 0;
for (int i = n - 1; i >= 0; i--) {
long long o = 0;
for (int j = 20; j >= 0; j--)
if ((a[i] & (1 << j)) == 0 && first[o | (1 << j)] >= 2) o |= (1 << j);
if (i < n - 2) res = max(res, a[i] | o);
queue<int> q;
q.push(a[i]);
vector<int> met;
mk[a[i]] = 1;
met.push_back(a[i]);
while (!q.empty()) {
int u = q.front();
q.pop();
if (first[u] >= 2) continue;
first[u]++;
for (int j = 0; j <= 20; j++)
if (u & (1 << j) && !mk[u - (1 << j)]) {
mk[u - (1 << j)] = 1;
met.push_back(u - (1 << j));
q.push(u - (1 << j));
}
}
for (auto y : met) mk[y] = 0;
}
cout << (res) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int K = 21;
const int N = (1 << K) + 3;
int n;
int a[N];
int b[N];
int ans;
void solve(int x) {
if (b[0] < 2) return;
int y = 0;
for (int k = K - 1; k >= 0; k--) {
if ((x >> k) & 1) continue;
if (b[y ^ (1 << k)] >= 2) {
y ^= 1 << k;
}
}
ans = max(ans, x | y);
}
void add(int x, int k) {
if (b[x] >= 2) return;
b[x]++;
while (k < K) {
if ((x >> k) & 1) {
add(x ^ (1 << k), k + 1);
}
k++;
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = n - 1; i >= 0; i--) {
solve(a[i]);
add(a[i], 0);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
const int MAX_N = 21;
vector<int> G[1 << MAX_N];
int N, A[1 << MAX_N];
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", &A[i]);
G[A[i]].push_back(i);
}
for (int i = 0; i < (1 << MAX_N); i++) {
sort(G[i].begin(), G[i].end());
reverse(G[i].begin(), G[i].end());
}
for (int i = (1 << MAX_N) - 1; i >= 0; i--) {
int p1 = -1, p2 = -1, p3 = -1;
if (G[i].size() >= 1) p1 = G[i][0];
if (G[i].size() >= 2) p2 = G[i][1];
for (int j = 0; j < MAX_N; j++) {
if ((i & (1 << j)) != 0) continue;
for (int k : G[i + (1 << j)]) {
if (p1 == k || p2 == k) continue;
p3 = k;
if (p2 < p3) swap(p2, p3);
if (p1 < p2) swap(p1, p2);
}
}
G[i].clear();
if (p1 != -1) G[i].push_back(p1);
if (p2 != -1) G[i].push_back(p2);
}
int cur = 0;
for (int i = MAX_N - 1; i >= 0; i--) {
int mask = cur + (1 << i);
bool flag = false;
for (int j = 0; j < N; j++) {
int s = (mask & ((1 << MAX_N) - 1 - A[j]));
if (G[s].size() == 2 && G[s][1] > j) flag = true;
}
if (flag == true) cur = mask;
}
cout << cur << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3000000 + 100;
int n, a[maxn], f[maxn];
void add(int x, int b = 0) {
if (f[x] >= 2) return;
f[x]++;
for (int i = b; i <= 20; i++) {
if ((x >> i) & 1) {
add(x ^ (1 << i), i);
}
}
}
void work() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int ret = 0;
for (int i = n - 1; i >= 0; i--) {
int s = 0;
for (int j = 20; j >= 0; j--) {
if ((a[i] >> j) & 1) continue;
int t = s | (1 << j);
if (f[t] == 2) {
s = t;
}
}
add(a[i]);
if (i <= n - 3) ret = max(ret, a[i] | s);
}
printf("%d\n", ret);
}
int main() {
int TestCase = 1;
while (TestCase--) {
work();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace red {
inline int read() {
int x = 0;
char ch, f = 1;
for (ch = getchar(); (ch < '0' || ch > '9') && ch != '-'; ch = getchar())
;
if (ch == '-') f = 0, ch = getchar();
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return f ? x : -x;
}
const int N = 2e6 + 10, inf = 1 << 30;
int n, ans;
int a[N];
pair<int, int> dp[N];
inline void update(int x, int pos) {
if (dp[x].first < pos) {
dp[x].second = dp[x].first;
dp[x].first = pos;
} else if (dp[x].second < pos && pos != dp[x].first)
dp[x].second = pos;
}
inline void SOSdp() {
for (int s = N - 1; ~s; --s) {
for (int i = 20; ~i; --i) {
if ((s >> i) & 1) {
update(s ^ (1 << i), dp[s].first);
update(s ^ (1 << i), dp[s].second);
}
}
}
}
inline void main() {
n = read();
for (int i = 1; i <= n; ++i) a[i] = read(), update(a[i], i);
SOSdp();
for (int i = 1; i <= n - 2; ++i) {
int w = 0;
for (int j = 20; ~j; --j) {
if (!((a[i] >> j) & 1) && dp[w | (1 << j)].first > i &&
dp[w | (1 << j)].second > i)
w = w | (1 << j);
}
ans = max(ans, a[i] | w);
}
printf("%d", ans);
}
} // namespace red
signed main() {
red::main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1e6 + 50;
const int maxa = 2e6 + 50;
int n, a[maxn];
pair<int, int> dp[maxa];
void updata(int x, int pos) {
if (dp[x].first < pos) {
dp[x].second = dp[x].first;
dp[x].first = pos;
} else if (dp[x].second < pos && pos != dp[x].first)
dp[x].second = pos;
}
void get_dp() {
for (int i = 20; i >= 0; i--)
for (int x = 0; x <= maxa - 1; x++) {
if (((x >> i) & 1) == 1) {
updata(x ^ (1 << i), dp[x].first);
updata(x ^ (1 << i), dp[x].second);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
updata(a[i], i);
}
get_dp();
int ans = 0;
for (int i = 1; i <= n - 2; i++) {
int w = 0;
for (int j = 20; j >= 0; j--) {
if (((a[i] >> j) & 1) == 0 && dp[w | (1 << j)].first > i &&
dp[w | (1 << j)].second > i)
w = w | (1 << j);
}
ans = max(ans, a[i] | w);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2.5e6 + 3, S = 21;
struct data {
int a, b;
inline friend void merge(data &x, data &y) {
x.b = max(min(x.a, y.a), max(x.b, y.b));
x.a = max(x.a, y.a);
}
};
data f[N];
int a[N];
int main() {
int n, mx = 0, s;
scanf("%d", &n);
for (register int i = 1; i <= n; i++) {
scanf("%d", a + i);
mx = max(mx, a[i]);
}
s = 31 - __builtin_clz(mx);
for (register int i = n; i; i--) {
if (!f[a[i]].a)
f[a[i]].a = i;
else if (f[a[i]].a && !f[a[i]].b)
f[a[i]].b = i;
}
for (register int i = 1; i <= mx; i <<= 1)
for (register int j = i; j <= mx; j += i << 1)
for (register int k = j; k < j + i && k <= mx; k++) merge(f[k - i], f[k]);
int ans = 0;
for (register int i = 1; i <= n - 2; i++) {
int nw = 0;
for (register int j = s; ~j; j--)
if (a[i] >> j & 1 ^ 1 && f[nw | 1 << j].b > i) nw |= 1 << j;
ans = max(ans, a[i] | nw);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1 << 22];
int main() {
std::ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
function<void(int, int, bool)> update = [&](int num, int k, bool flag) {
if (k > 21 || dp[num] >= 3) return;
if (flag) dp[num]++;
update(num, k + 1, false);
if ((num >> k) & 1) update(num ^ (1 << k), k, true);
};
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
int res = 0, t = 0;
for (int j = 21; j >= 0; j--) {
if ((a[i] >> j) & 1)
res |= (1 << j);
else if (dp[t | (1 << j)] >= 2)
res |= (1 << j), t |= (1 << j);
}
update(a[i], 0, true);
if (i < n - 2) ans = max(ans, res);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long bucket[1 << 21], Copy[1 << 21];
int n, arrey[1000010];
char *p1, *p2, buf[100000];
int rd() {
int x = 0, f = 1;
char Copy =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++);
while (Copy < 48) {
if (Copy == '-') f = -1;
Copy =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++);
}
while (Copy > 47) {
x = (((x << 2) + x) << 1) + (Copy ^ 48),
Copy =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++);
}
return x * f;
}
void fwt1(long long *arrey, int n, int flag) {
for (int k = 2; k <= n; k <<= 1) {
for (int i = 0, t = k >> 1; i < n; i += k) {
for (int j = i; j < i + t; j++) {
arrey[j] = arrey[j] + arrey[j + t] * flag;
}
}
}
}
void fwt2(long long *arrey, int n, int flag) {
for (int k = 2; k <= n; k <<= 1) {
for (int i = 0, t = k >> 1; i < n; i += k) {
for (int j = i; j < i + t; j++) {
arrey[j + t] = flag * arrey[j] + arrey[j + t];
}
}
}
}
int main() {
n = rd();
for (int i = 1; i <= n; i++) {
bucket[arrey[i] = rd()]++;
}
fwt2(bucket, (1 << 21), 1);
for (int i = 0; i < (1 << 21); i++) {
bucket[i] = bucket[i] * bucket[i];
}
fwt2(bucket, (1 << 21), -1);
for (int i = 1; i <= n; i++) {
bucket[arrey[i]]--;
}
for (int i = 0; i < (1 << 21); i++) {
bucket[i] /= 2;
}
memcpy(Copy, bucket, sizeof Copy);
fwt1(bucket, (1 << 21), 1);
for (int i = 0; i < (1 << 21); i++) {
bucket[i] = bucket[i] * bucket[i];
}
fwt1(bucket, (1 << 21), -1);
for (int i = 0; i < (1 << 21); i++) {
bucket[i] -= Copy[i];
}
for (int i = (1 << 21) - 1; ~i; i--) {
if (bucket[i]) {
cout << i << endl;
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int l, int r) { return l + rng() % (r - l + 1); }
const int N = (1 << 22) + 5;
int f1[N], f2[N], a[N], n;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
f1[a[i]] = f2[a[i]];
f2[a[i]] = i;
}
int ma = (1 << 22) - 1;
for (int i = 0; i <= 21; ++i) {
for (int j = ma; j >= 0; j--)
if (!((j >> i) & 1)) {
if (f2[j] < f2[(j ^ (1 << i))]) {
f1[j] = f2[j];
f2[j] = f2[(j ^ (1 << i))];
f1[j] = max(f1[j], f1[(j ^ (1 << i))]);
} else
f1[j] = max(f1[j], f2[(j ^ (1 << i))]);
}
}
int kq = 0;
for (int i = 1; i <= n - 2; ++i) {
int res = 0;
for (int j = 21; j >= 0; j--) {
int tmp = res;
if (!((a[i] >> j) & 1)) tmp += (1 << j);
if (f1[tmp] > i) res = tmp;
}
kq = max(kq, (res | a[i]));
}
cout << kq;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
pair<int, int> marge(pair<int, int> p, pair<int, int> q) {
if (p.first > q.first) {
return {p.first, max(q.first, p.second)};
} else {
return {q.first, max(p.first, q.second)};
}
}
int main() {
int n;
cin >> n;
int a[n];
for (int i = (int)(0); i < (int)(n); ++i) scanf("%d", &a[i]);
vector<pair<int, int>> cnt(1 << 22, {-1, -1});
for (int i = (int)(0); i < (int)(n); ++i) {
cnt[a[i]] = marge(cnt[a[i]], {i, -1});
}
for (int i = (int)(0); i < (int)(22); ++i) {
for (int j = (int)(0); j < (int)(1 << 22); ++j)
if (j & (1 << i)) cnt[j ^ (1 << i)] = marge(cnt[j ^ (1 << i)], cnt[j]);
}
int ans = 0;
for (int i = (int)(0); i < (int)(n - 2); ++i) {
int cur = 0;
for (int j = 21; j >= 0; --j) {
if (a[i] & (1 << j))
continue;
else if (cnt[cur ^ (1 << j)].second > i)
cur ^= (1 << j);
}
ans = max(ans, a[i] | cur);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[25], temp[(1 << 22) - 1], a[1000005];
void f(int x, int k) {
if (temp[x] >= 2) return;
temp[x]++;
while (k <= 21) {
if (x & p[k]) f(x ^ p[k], k + 1);
k++;
}
}
void solve() {
int n, res = 0;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
temp[0] = 1;
f(a[n], 0), f(a[n - 1], 0);
for (int i = n - 2; i >= 1; i--) {
int x = 0;
for (int j = 21; j >= 0; j--)
if (!(a[i] & p[j])) {
x ^= p[j];
if (temp[x] < 2) x ^= p[j];
}
res = max(res, (x ^ a[i]));
f(a[i], 0);
}
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
clock_t z = clock();
p[0] = 1;
for (int i = 1; i < 25; i++) p[i] = 2 * p[i - 1];
int qc = 1;
for (int i = 1; i <= qc; i++) {
solve();
}
fprintf(stderr, "Total Time:%.4Lf\n",
(long double)(clock() - z) / CLOCKS_PER_SEC),
fflush(stderr);
}
|
#include <bits/stdc++.h>
using namespace std;
const int BITS = 21;
const int N = 1e6 + 111;
int n, A[N];
pair<int, int> P[1 << BITS];
int res;
void Update(int mask, int pos) {
if (P[mask].first == -1)
P[mask].first = pos;
else if (P[mask].second == -1) {
if (P[mask].first < pos)
P[mask].second = pos;
else if (pos < P[mask].first) {
P[mask].second = P[mask].first;
P[mask].first = pos;
}
} else {
if (P[mask].second < pos) {
P[mask].first = P[mask].second;
P[mask].second = pos;
} else if (P[mask].first < pos)
P[mask].first = pos;
}
}
void Merge(int mask_1, int mask_2) {
if (P[mask_2].first != -1) Update(mask_1, P[mask_2].first);
if (P[mask_2].second != -1) Update(mask_1, P[mask_2].second);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> A[i];
memset(P, -1, sizeof(P));
for (int i = 1; i <= n; ++i) Update(A[i], i);
for (int i = 0; i < BITS; ++i) {
for (int mask = 0; mask < (1 << BITS); ++mask) {
if (mask & (1 << i)) {
Merge(mask ^ (1 << i), mask);
}
}
}
for (int i = 1; i <= n; ++i) {
int off_bit = (1 << BITS) - 1 - A[i];
int opt = 0;
for (int j = BITS - 1; j >= 0; --j) {
if (off_bit & (1 << j)) {
if (P[opt | (1 << j)].second != -1 && P[opt | (1 << j)].first > i)
opt |= (1 << j);
}
}
if (P[opt].second != -1 && P[opt].first > i) res = max(res, (A[i] | opt));
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int L = 20;
int a[1000001];
vector<int> g[3000001];
int cnt[3000010];
bool used[3000010];
vector<int> u;
void dfs(int mask) {
if (used[mask]) return;
used[mask] = true;
u.push_back(mask);
if (cnt[mask] >= 2) return;
cnt[mask]++;
for (int i = 0; i <= L; i++) {
if (mask & (1 << i)) {
dfs(mask ^ (1 << i));
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int maxx = 0;
for (int i = n; i >= 1; i--) {
if (i + 2 <= n) {
int mask = 0;
for (int j = L; j >= 0; j--) {
if (a[i] & (1 << j)) continue;
if (cnt[mask ^ (1 << j)] >= 2) mask ^= (1 << j);
}
maxx = max(maxx, (mask ^ a[i]));
}
dfs(a[i]);
for (auto j : u) used[j] = false;
u.clear();
}
cout << maxx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
x = 0;
int f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -f;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
x *= f;
}
void print(int x) {
if (x < 0) putchar('-'), x = -x;
if (!x) return;
print(x / 10), putchar(x % 10 + 48);
}
void write(int x) {
if (!x)
putchar('0');
else
print(x);
putchar('\n');
}
const int maxn = 4e6 + 10;
const int inf = 1e9;
const double eps = 1e-8;
const int mod = 1e9 + 7;
int a[maxn], r[maxn], n;
void ins(int x, int p) {
if (r[x] >= 2) return;
if (p == -1) return r[x]++, void();
ins(x, p - 1);
if (x & (1 << p)) ins(x - (1 << p), p - 1);
}
int get(int x) {
int res = 0, s = 0;
for (int i = 20; ~i; i--)
if (x & (1 << i))
res += 1 << i;
else if (r[s + (1 << i)] >= 2)
res += 1 << i, s += 1 << i;
return res;
}
int main() {
read(n);
for (int i = 1; i <= n; i++) read(a[i]);
int ans = 0;
for (int i = n; i; i--) {
if (i <= n - 2) ans = max(ans, get(a[i]));
ins(a[i], 20);
}
write(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int a[N], maxf[1 << 21], maxs[1 << 21], bit[25], n;
inline void update(int u, int d) {
if (maxf[u] < d) {
maxs[u] = maxf[u];
maxf[u] = d;
} else if (maxs[u] < d)
maxs[u] = d;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 2; i <= n; i++) {
if (maxf[a[i]]) {
maxs[a[i]] = maxf[a[i]];
maxf[a[i]] = i;
}
maxf[a[i]] = i;
}
bit[0] = 1;
for (int i = 1; i <= 21; i++) bit[i] = bit[i - 1] * 2;
for (int i = 0; i < 21; i++) {
for (int s = 0; s < bit[21]; s++) {
if (s & bit[i]) {
update(s ^ bit[i], maxf[s]);
update(s ^ bit[i], maxs[s]);
}
}
}
int ans = 0;
for (int i = 1; i <= n - 2; i++) {
int u = 0;
for (int k = 20; k >= 0; k--) {
if (a[i] & bit[k]) continue;
if (maxs[u | bit[k]] > i) u |= bit[k];
}
ans = max(ans, a[i] | u);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 21;
int a[N], b[N];
int n, ans;
void query(int x) {
if (b[0] < 2) return;
int y = 0;
for (int k = 20; k >= 0; k--) {
if ((x >> k) & 1) continue;
if (b[y ^ (1 << k)] >= 2) y ^= 1 << k;
}
ans = max(ans, x | y);
}
void update(int x, int k) {
if (b[x] >= 2) return;
b[x]++;
while (k < 21) {
if ((x >> k) & 1) update(x ^ (1 << k), k + 1);
k++;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = n; i >= 1; i--) {
query(a[i]);
update(a[i], 0);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(long long a) {
write(a);
puts("");
}
inline void wri(long long a) {
write(a);
putchar(' ');
}
inline unsigned long long rnd() {
return ((unsigned long long)rand() << 30 ^ rand()) << 4 | rand() % 4;
}
const int N = 1 << 20 | 2, m = 21;
int a[N], f[N << 1][2], ans;
int main() {
int n = read();
for (int i = (int)(1); i <= (int)(n); i++) {
a[i] = read();
f[a[i]][1] = f[a[i]][0];
f[a[i]][0] = i;
}
for (int i = (int)(0); i <= (int)(m - 1); i++)
for (int j = (int)(0); j <= (int)((1 << m) - 1); j++)
if (j >> i & 1) {
if (f[j ^ (1 << i)][0] > f[j][0]) {
f[j ^ (1 << i)][1] = max(f[j ^ (1 << i)][1], f[j][0]);
} else {
f[j ^ (1 << i)][1] = f[j ^ (1 << i)][0];
f[j ^ (1 << i)][0] = f[j][0];
f[j ^ (1 << i)][1] = max(f[j ^ (1 << i)][1], f[j][1]);
}
}
for (int i = (int)(1); i <= (int)(n - 2); i++) {
int dq = 0;
for (int j = (int)(m - 1); j >= (int)(0); j--)
if ((a[i] >> j & 1) == 0) {
if (f[dq | (1 << j)][1] > i) dq |= 1 << j;
}
ans = max(ans, a[i] | dq);
}
writeln(ans);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.