text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1048576 + 10, M = 19, MOD = 1000000007;
int n, ans, f[maxn];
int Pow(long long a, int b) {
long long res = 1;
for (; b; b >>= 1, a = a * a % MOD)
if (b & 1) res = (res * a) % MOD;
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
f[x]++;
}
for (int i = 0; i <= M; i++)
for (int j = 0; j <= (1 << M + 1) - 1; j++)
if (!((j >> i) & 1)) (f[j] += f[j | (1 << i)]) %= MOD;
for (int i = 0; i <= (1 << M + 1) - 1; i++) {
int cnt = 0;
for (int j = 0; j <= M; j++)
if ((i >> j) & 1) cnt++;
(ans += ((cnt & 1) ? -1 : 1) * (Pow(2, f[i]) - 1)) %= MOD;
}
printf("%d\n", (ans + MOD) % MOD);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, m, dp[2][1200005], f[1200005];
inline int exp(int x, int y) {
int ans = 1;
while (y) {
if (y & 1) ans = (long long)ans * x % mod;
x = (long long)x * x % mod;
y >>= 1;
}
return ans;
}
int main() {
scanf("%d", &n);
int k = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
dp[k][x]++;
m = max(m, x);
f[x]++;
}
n = 2;
while (n <= m) n <<= 1;
for (int i = 1; i < 20; i++) {
k ^= 1;
for (int j = 0; j < n; j++) {
dp[k][j] = 0;
for (int l = 0; l < 20; l++)
if (!(j & (1 << l))) dp[k][j] += dp[k ^ 1][j ^ (1 << l)];
dp[k][j] /= i;
f[j] = f[j] + dp[k][j];
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (f[i] < 0) return 0;
int num = 0, t = exp(2, f[i]);
for (int j = 0; j < 20; j++)
if (i & (1 << j)) num++;
if (num & 1)
ans = (ans - t + mod) % mod;
else
ans = (ans + t) % mod;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const int V = (1 << 20) + 10;
const int P = 1000000007;
int Pow(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = (long long)ret * x % P;
x = (long long)x * x % P;
y /= 2;
}
return ret;
}
void utf(int *a, int l, int r) {
if (l + 1 != r) {
int mid = (l + r) / 2;
for (int i = 0; i < mid - l; i++) {
a[l + i] -= a[mid + i];
if (a[l + i] < 0) a[l + i] += P;
}
utf(a, l, mid);
utf(a, mid, r);
}
}
void tf(int *a, int l, int r) {
if (l + 1 != r) {
int mid = (l + r) / 2;
tf(a, l, mid);
tf(a, mid, r);
for (int i = 0; i < mid - l; i++) {
a[l + i] += a[mid + i];
if (a[l + i] >= P) a[i + l] -= P;
}
}
}
int cnt[V], q[V];
int n, x, pro[V];
int pt[V];
int main() {
pt[0] = 1;
for (int i = 1; i < (1 << N); i++) pt[i] = pt[i - 1] * 2 % P;
while (~scanf("%d", &n)) {
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n; i++) {
scanf("%d", &x);
cnt[x]++;
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < (1 << N); j++) {
if (j & (1 << i)) {
cnt[j ^ (1 << i)] += cnt[j];
}
}
}
for (int i = 0; i < (1 << N); i++) pro[i] = pt[cnt[i]];
utf(pro, 0, (1 << N));
printf("%d\n", pro[0]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[2000010];
inline int inn() {
int x, ch;
while ((ch = getchar()) < '0' || ch > '9')
;
x = ch ^ '0';
while ((ch = getchar()) >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ '0');
return x;
}
inline void fwt(int *a, int n) {
for (int i = 1; i < n; i <<= 1)
for (int j = 0, p = i << 1; j < n; j += p)
for (int k = 0; k < i; k++) (a[j + k] += a[j + k + i]) %= 1000000007;
}
inline int solve(int x, int s) {
int res = 0;
while (s) res ^= s & 1, s >>= 1;
return res ? (1000000007 - x) % 1000000007 : x;
}
inline int fast_pow(int x, int k, int ans = 1) {
for (; k; k >>= 1, x = (long long)x * x % 1000000007)
(k & 1) ? ans = (long long)ans * x % 1000000007 : 0;
return ans;
}
int main() {
int n = inn(), A = 0, m = 1, ans = 0;
for (int i = 1, x; i <= n; i++) cnt[x = inn()]++, A = max(A, x);
while (m <= A) m <<= 1;
fwt(cnt, m);
for (int i = 0; i < m; i++)
(ans += solve(fast_pow(2, cnt[i]), i)) %= 1000000007;
if (!A) ans--;
if (ans < 0) ans += 1000000007;
return !printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int BITS = 20;
const int MAXN = 1 << BITS;
const long long mod = 1e9 + 7;
void subsets(int* A, int nb) {
if (nb == 0) return;
int half = 1 << (nb - 1);
subsets(A, nb - 1);
subsets(A + half, nb - 1);
for (int i = (0); i < int(half); ++i)
tie(A[i], A[i + half]) = make_tuple(A[i] + A[i + half], A[i + half]);
}
int main(void) {
static int frek[MAXN];
memset(frek, 0, sizeof frek);
int n;
scanf("%d", &n);
for (int i = (0); i < int(n); ++i) {
int x;
scanf("%d", &x);
++frek[x];
}
static long long pow2[MAXN];
for (int i = (0); i < int(MAXN); ++i)
pow2[i] = (i == 0) ? 1 : pow2[i - 1] * 2 % mod;
subsets(frek, BITS);
long long ans = 0;
for (int st = (0); st < int(MAXN); ++st) {
int sign = 1;
for (int i = (0); i < int(BITS); ++i)
if (st & (1 << i)) sign = -sign;
ans = (ans + sign * pow2[frek[st]]) % mod;
}
printf("%lld\n", (ans % mod + mod) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int sz = 20, mod = 1e9 + 7;
int dp[1 << sz], st[1 << sz];
int main() {
int n, an = 0;
cin >> n;
for (int a = 0; a < n; a++) {
int x;
scanf("%d", &x);
dp[x]++;
st[a + 1] = (st[a] * 2 + 1) % mod;
}
for (int i = 0; i < sz; i++) {
for (int mask = 0; mask < (1 << sz); mask++) {
if ((mask & (1 << i)) == 0) dp[mask] += dp[mask + (1 << i)];
}
}
for (int mask = 0; mask < (1 << sz); mask++) {
int q = __builtin_popcount(mask);
if (q & 1)
an -= st[dp[mask]];
else
an += st[dp[mask]];
if (an < 0) an += mod;
if (an >= mod) an -= mod;
}
cout << an;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[21][(1 << 20)], pw[1000005];
int main() {
int n, i, x, mask, cnt;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> x;
dp[0][x]++;
}
for (i = 1; i <= 20; i++) {
for (mask = 0; mask < (1 << 20); ++mask) {
if (mask & (1 << (i - 1)))
dp[i][mask] = dp[i - 1][mask];
else {
dp[i][mask] = dp[i - 1][mask] + dp[i - 1][mask + (1 << (i - 1))];
}
}
}
pw[0] = 1;
for (i = 1; i < 1000005; i++) pw[i] = (pw[i - 1] * 2LL) % 1000000007;
long long ans = 0;
for (mask = 0; mask < (1 << 20); mask++) {
cnt = 0;
for (i = 0; i < 20; i++) {
if (mask & (1 << i)) cnt ^= 1;
}
if (cnt) {
ans -= pw[dp[20][mask]];
if (ans < 0) ans += 1000000007;
} else {
ans += pw[dp[20][mask]];
if (ans >= 1000000007) ans -= 1000000007;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a;
long long int f[21][1000005], ans;
long long int fastexp(long long int b, long long int e) {
long long int res = 1;
while (e) {
if (e & 1) res = (res * b) % 1000000007;
e >>= 1;
b = (b * b) % 1000000007;
}
return res;
}
long long int dp(int k, int x) {
if (x > 1000000) return 0;
if (f[k][x] == -1) {
f[k][x] = dp(k - 1, x);
if (!(x & (1 << (k - 1))))
f[k][x] = (f[k][x] + dp(k - 1, x + (1 << (k - 1)))) % 1000000007;
}
return f[k][x];
}
int main() {
scanf("%d", &n);
memset(f, -1, sizeof f);
memset(f[0], 0, sizeof f[0]);
for (int i = 0; i < n; i++) {
scanf("%d", &a);
f[0][a]++;
}
ans = 0;
for (int i = 0; i < (1 << 20); i++)
if (__builtin_popcount(i) & 1)
ans = (ans - fastexp((long long int)2, dp(20, i)) + 1000000007) %
1000000007;
else
ans = (ans + fastexp((long long int)2, dp(20, i))) % 1000000007;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1048576;
int f[M + 10], pw[M + 10];
int siz[M + 10];
int main() {
int n;
scanf("%d", &n);
pw[0] = 1;
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
f[a]++;
pw[i] = pw[i - 1] << 1;
if (pw[i] >= 1000000007) pw[i] -= 1000000007;
}
for (int step = 1; step < M; step <<= 1)
for (int i = 0; i < M; i += step << 1)
for (int j = i; j < i + step; j++) {
f[j] += f[j + step];
if (f[j] >= 1000000007) f[j] -= 1000000007;
}
for (int i = 1; i < M; i++) siz[i] = siz[i >> 1] + (i & 1);
int ans = 0;
for (int i = 0; i < M; i++) {
if (siz[i] & 1)
ans -= pw[f[i]];
else
ans += pw[f[i]];
if (ans >= 1000000007) ans -= 1000000007;
if (ans < 0) ans += 1000000007;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int pow(int a, int n) {
int res = 1;
while (n) {
if (n & 1) res = 1LL * res * a % mod;
a = 1LL * a * a % mod;
n >>= 1;
}
return res;
}
void solve(int f[], int n, int ty) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << n); j++) {
if (j & (1 << i)) continue;
if ((f[j | (1 << i)] += ty * f[j]) >= mod) f[j | (1 << i)] -= mod;
if ((f[j | (1 << i)]) < 0) f[j | (1 << i)] += mod;
}
}
}
int f[1 << 20];
int main() {
int n;
scanf("%d", &n);
int mask = (1 << 20) - 1;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
f[x ^ mask]++;
}
solve(f, 20, 1);
for (int i = 0; i < (1 << 20); i++) {
f[i] = pow(2, f[i]);
}
solve(f, 20, -1);
printf("%d\n", f[mask]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const int MAXN = 2e6 + 10;
const int MOD = 1e9 + 7;
int cnt[MAXN], q[MAXN];
long long pow2[MAXN];
void build(int l, int r) {
if (r - l == 1) {
q[l] = cnt[l];
return;
}
int mid = (l + r) / 2;
build(l, mid);
build(mid, r);
for (int a = l; a < mid; ++a) q[a] = q[a] + q[a + mid - l];
}
int main() {
int n;
scanf("%d", &n);
for (int a = 0; a < n; ++a) {
int x;
scanf("%d", &x);
cnt[x]++;
}
pow2[0] = 1;
for (int a = 1; a < MAXN; ++a) pow2[a] = (2 * pow2[a - 1]) % MOD;
build(0, 1 << 20);
long long ans = 0;
for (int m = 0; m < (1 << 20); ++m) {
if (__builtin_popcount(m) & 1)
ans -= pow2[q[m]];
else
ans += pow2[q[m]];
ans %= MOD;
}
cout << (ans + MOD) % MOD << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using vi = vector<long long>;
using vvi = vector<vi>;
using P = pair<long long, long long>;
using PP = tuple<long long, long long, long long>;
using vp = vector<P>;
using vvp = vector<vp>;
template <class T>
void out(T a) {
cout << a << '\n';
}
template <class T>
void outv(T v) {
for (long long i = 0; i < (long long)(v.size()); i++) {
if (i) cout << ' ';
cout << v[i];
}
cout << '\n';
}
template <class T>
void outvv(T v) {
for (long long i = 0; i < (long long)(v.size()); i++) outv(v[i]);
}
template <class T>
bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const long long inf = 1001001001001001001;
const int mod = 1000000007;
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
long long modpow(long long a, long long b) {
a %= mod;
if (b == 0) return 1ll;
if (b & 1) return a * modpow(a, b - 1) % mod;
long long k = modpow(a, b / 2);
return k * k % mod;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long n, l = 20;
cin >> n;
vi v(1 << l);
for (long long i = 0; i < (long long)(n); i++) {
long long a;
cin >> a;
v[a ^ ((1 << l) - 1)]++;
}
vvi dp(1 << l, vi(l + 1));
for (long long i = 0; i < (long long)(1 << l); i++) {
dp[i][0] = v[i];
for (long long j = 0; j < (long long)(l); j++) {
dp[i][j + 1] += dp[i][j];
if (i >> j & 1) dp[i][j + 1] += dp[i & ~(1 << j)][j];
}
}
long long ans = 0;
for (long long i = 0; i < (long long)(1 << l); i++) {
long long c = __builtin_popcount(i);
if (c & 1)
ans -= modpow(2, dp[i][l]);
else
ans += modpow(2, dp[i][l]);
ans %= mod;
}
ans += mod;
out(ans % mod);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MV = 1048576, ML = 20, MOD = 1e9 + 7;
int N, freq[MV], sup[MV];
long long int pow2(int n) {
long long int base = 2, res = 1;
while (n) {
if (n & 1) res = res * base % MOD;
base = base * base % MOD;
n /= 2;
}
return res;
}
int main() {
int n;
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", &n);
++freq[n];
}
for (int m = 0; m < MV; m++) sup[m] = freq[m];
for (int i = 0; i < 20; i++)
for (int m = 0; m < MV; m++)
if (!(m & (1 << i))) sup[m] += sup[m ^ (1 << i)];
long long int ans = 0;
for (int m = 1; m < MV; m++) {
if (__builtin_popcount(m) & 1)
ans = (ans + pow2(sup[m]) - 1) % MOD;
else
ans = (ans + 1 + MOD - pow2(sup[m])) % MOD;
}
printf("%lld\n", (pow2(N) + MOD - ans - 1) % MOD);
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 5;
int n;
int a[maxn];
int dp[(1 << 21)][21];
long long powmod(long long x, long long y, long long m) {
long long z = x % m;
if (!y) return 1;
if (y & 1)
return z * powmod(z * z, (y - 1) / 2, m) % m;
else
return powmod(z * z, y / 2, m) % m;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) dp[a[i]][0]++;
for (int i = 1; i < 21; i++) {
for (int j = 0; j < (1 << 21); j++) {
if ((j >> (i - 1)) & 1)
dp[j][i] = dp[j][i - 1];
else
dp[j][i] = dp[j][i - 1] + dp[j + (1 << (i - 1))][i - 1];
}
}
long long ans = 0;
for (int i = 0; i < (1 << 21); i++) {
long long cur = powmod(2, dp[i][20], mod) - 1;
if (__builtin_popcount(i) & 1) cur = -cur;
ans += cur + mod;
ans %= mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000100;
const long long MOD = 1e9 + 7;
int n;
long long fac[MAXN], inv[MAXN];
long long quick_pow(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return ret;
}
void init() {
fac[0] = 1;
for (int i = 1; i < MAXN; ++i) fac[i] = fac[i - 1] * i % MOD;
inv[MAXN - 1] = quick_pow(fac[MAXN - 1], MOD - 2);
for (int i = MAXN - 2; i >= 0; --i) inv[i] = inv[i + 1] * (i + 1) % MOD;
assert(inv[0] == 1);
}
long long C(int n, int m) {
if (m > n) return 0;
return fac[n] * inv[m] % MOD * inv[n - m] % MOD;
}
long long dp[MAXN], f[MAXN];
int main() {
init();
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
++dp[x];
}
for (int i = 0; i < 20; ++i) {
for (int s = 0; s < MAXN; ++s)
if (s & (1 << i)) dp[s ^ (1 << i)] += dp[s];
}
long long ans = quick_pow(2, n) - 1;
f[0] = 0;
for (int s = 1; s < MAXN; ++s) {
f[s] = f[(s - 1) & s] + 1;
int flag = (f[s] & 1) ? -1 : 1;
ans = (ans + flag * (quick_pow(2, dp[s]) - 1)) % MOD;
}
ans = (ans % MOD + MOD) % MOD;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007ll;
long long dp[(1 << 20)][21], p[(1 << 20)], a[(1 << 20)] = {0};
inline long long add(long long p, long long q) {
long long ret = p + q;
return ((ret >= mod) ? ret - mod : ret);
}
int main() {
int n, l, lim, mx = 0;
scanf("%d", &n);
p[0] = 1;
for (int i = 1; i < (1 << 20); ++i) p[i] = add(p[i - 1], p[i - 1]);
for (int i = 0; i < n; ++i) {
int b;
scanf("%d", &b);
mx = (((mx) > (b)) ? (mx) : (b));
++a[b];
}
l = log2(mx);
lim = (1 << (l + 1));
for (int i = 0; i < lim; ++i) {
if (i & 1)
dp[i][0] = a[i];
else
dp[i][0] = a[i] + a[i ^ 1];
}
for (int i = 1; i <= l; ++i) {
for (int j = 0; j < lim; ++j) {
if (j & p[i])
dp[j][i] = dp[j][i - 1];
else
dp[j][i] = add(dp[j][i - 1], dp[j ^ p[i]][i - 1]);
}
}
long long ans = 0, prv = 0;
for (int i = 0; i < lim; ++i) {
if (__builtin_popcount(i) & 1)
ans = add(ans, mod - p[dp[i][l]]);
else
ans = add(ans, p[dp[i][l]]);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 20);
int cnt[maxn];
long long f[maxn];
const long long MOD = 1e9 + 7;
long long pw(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % MOD;
b >>= 1;
a = a * a % MOD;
}
return res;
}
int sign(int i) {
if (i & 1) return -1;
return 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
int a;
cin >> a;
++cnt[a];
}
for (int i = 0; i <= 1000000; ++i) f[i] = cnt[i];
for (int b = 0; b < 20; ++b) {
for (int i = 0; i <= 1000000; ++i) {
if (!(i & (1 << b))) f[i] += f[i ^ (1 << b)];
}
}
long long ans = 0;
for (int i = 0; i <= 1000000; ++i) {
ans += sign(__builtin_popcount(i)) * (pw(2, f[i]) - 1);
if (ans < 0) ans += MOD;
if (ans >= MOD) ans -= MOD;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
long long dp[1 << 20];
long long exp(long long a, int b) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
dp[a]++;
}
for (int i = 0; i < 20; i++) {
for (int mask = 0; mask < (1 << 20); mask++) {
if (mask & (1 << i)) {
dp[mask ^ (1 << i)] += dp[mask];
dp[mask] %= mod;
}
}
}
long long ans = 0;
for (int mask = 0; mask < (1 << 20); mask++) {
if (dp[mask] == 0) continue;
if (__builtin_popcount(mask) & 1)
ans = (ans - (exp(2LL, dp[mask]) - 1) + mod) % mod;
else
ans = (ans + exp(2LL, dp[mask]) - 1) % mod;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
x = 0;
char c = getchar();
for (; c < 48; c = getchar())
;
for (; c > 47; c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
}
const int M = 1 << 20;
long long po[M];
int dp[2][M], cnt[M], sz = sizeof(dp[0]), op[M];
int main() {
int n;
read(n);
int i, x, now = 0;
po[0] = 1;
for (i = 1; i <= n; i++) po[i] = (po[i - 1] * 2) % 1000000007;
long long res = 0;
for (; n--;) {
read(x);
cnt[x]++;
if (x & 1) {
dp[now][x]++;
dp[now][x ^ 1]++;
} else {
dp[now][x]++;
}
}
int tmp, j;
for (i = 1; i < 20; i++) {
tmp = 1 << i;
now = !now;
memset(dp[now], 0, sz);
for (j = 0; j < M; j++) {
(dp[now][j] += dp[!now][j]) %= 1000000007;
if (j & tmp) (dp[now][j ^ tmp] += dp[!now][j]) %= 1000000007;
}
}
op[0] = 1;
for (i = 0; i < M; i++) {
if (i) op[i] = -op[i ^ (i & (-i))];
res = (res + op[i] * (po[dp[now][i]] - 1)) % 1000000007;
}
printf("%lld\n", (res + 1000000007) % 1000000007);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int B = 1e9 + 7;
const int N = 1 << 20;
int n;
int f[21][N];
long long mypow(long long a, int b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % B;
a = a * a % B;
b >>= 1;
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 0, a; i < n; ++i) {
scanf("%d", &a);
if (a & 1) {
f[0][a]++;
f[0][a ^ 1]++;
} else {
f[0][a]++;
}
}
for (int i = 1; i <= 20; ++i) {
for (int x = 0; x < N; ++x) {
if (x >> i & 1) {
f[i][x] = f[i - 1][x];
} else {
f[i][x] = f[i - 1][x] + f[i - 1][x + (1 << i)];
}
}
}
long long ans = 0;
for (int x = 0; x < N; ++x) {
if (__builtin_popcount(x) & 1) {
ans = (ans + B - mypow(2, f[20][x])) % B;
} else {
ans = (ans + mypow(2, f[20][x])) % B;
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int up = (1 << 20);
const int MOD = (int)1e9 + 7;
int dp[2][up];
int modExp(int a, int b) {
long long t = 1, y = a;
while (b) {
if (b & 1) t = t * y % MOD;
y = y * y % MOD;
b >>= 1;
}
return (int)t;
}
int main() {
int n, t, ans = 0;
scanf("%d", &n);
int pre = 0, now = 1;
for (int i = 0; i < n; i++) {
scanf("%d", &t);
dp[pre][t]++;
}
for (int i = 0; i < 20; i++) {
memset(dp[now], 0, sizeof(dp[now]));
for (int j = 0; j < up; j++) {
if (j >> i & 1) {
dp[now][j] = dp[pre][j];
} else {
dp[now][j] = dp[pre][j] + dp[pre][j + (1 << i)];
dp[now][j] %= MOD;
}
}
pre ^= 1, now ^= 1;
}
for (int i = 0; i < up; i++) {
int cnt = __builtin_popcount(i);
int res = modExp(2, dp[pre][i]);
ans += (cnt & 1) ? -res : res;
ans = (ans % MOD + MOD) % MOD;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxlg = 21, MAXX = (1 << mxlg), MOD = 1e9 + 7;
int n, pw2[MAXX], dp[MAXX][mxlg], ans;
int sum(int x, int y) { return ((((x + y) % MOD) + MOD) % MOD); }
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n, pw2[0] = 1;
for (int i = 1; i < MAXX; i++) pw2[i] = (pw2[i - 1] * 2) % MOD;
for (int i = 0, x; i < n; i++) cin >> x, dp[x][0]++;
for (int j = 1; j < mxlg; j++) {
for (int i = 0; i < MAXX; i++) {
dp[i][j] = dp[i][j - 1];
if (!(i & (1 << (j - 1))))
dp[i][j] = (dp[i][j] + dp[i + (1 << (j - 1))][j - 1]);
}
}
for (int i = 0; i < MAXX; i++) {
int x = __builtin_popcount(i), y = pow(-1, x);
ans = sum(ans, (y * pw2[dp[i][mxlg - 1]]));
}
return cout << ans << endl, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using vi = vector<long long>;
using vvi = vector<vi>;
using P = pair<long long, long long>;
using PP = tuple<long long, long long, long long>;
using vp = vector<P>;
using vvp = vector<vp>;
template <class T>
void out(T a) {
cout << a << '\n';
}
template <class T>
void outv(T v) {
for (long long i = 0; i < (long long)(v.size()); i++) {
if (i) cout << ' ';
cout << v[i];
}
cout << '\n';
}
template <class T>
void outvv(T v) {
for (long long i = 0; i < (long long)(v.size()); i++) outv(v[i]);
}
template <class T>
bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const long long inf = 1001001001001001001;
const int mod = 1000000007;
long long modpow(long long a, long long b) {
a %= mod;
if (b == 0) return 1ll;
if (b & 1) return a * modpow(a, b - 1) % mod;
long long k = modpow(a, b / 2);
return k * k % mod;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long n, l = 20;
cin >> n;
vi v(1 << l);
for (long long i = 0; i < (long long)(n); i++) {
long long a;
cin >> a;
v[a ^ ((1 << l) - 1)]++;
}
vvi dp(1 << l, vi(l + 1));
for (long long i = 0; i < (long long)(1 << l); i++) {
dp[i][0] = v[i];
for (long long j = 0; j < (long long)(l); j++) {
dp[i][j + 1] += dp[i][j];
if (i >> j & 1) dp[i][j + 1] += dp[i & ~(1 << j)][j];
}
}
long long ans = 0;
for (long long i = 0; i < (long long)(1 << l); i++) {
long long c = __builtin_popcount(i);
if (c & 1)
ans -= modpow(2, dp[i][l]);
else
ans += modpow(2, dp[i][l]);
ans %= mod;
}
ans += mod;
out(ans % mod);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20) + 5;
const int MO = 1e9 + 7;
int a[N], cnt[N], pw[N] = {1};
void add(int &x, int y) {
x += y;
if (x >= MO) x -= MO;
}
int main() {
int n;
scanf("%d", &n);
for (int i = int(1); i <= int(n); i++) pw[i] = pw[i - 1], add(pw[i], pw[i]);
for (int i = int(1); i <= int(n); i++) scanf("%d", a + i), cnt[a[i]]++;
for (int i = int(0); i <= int((20) - 1); i++) {
for (int j = int(0); j <= int((1 << 20) - 1); j++) {
if ((j & (1 << i)) == 0) {
cnt[j] += cnt[j + (1 << i)];
}
}
}
int ans = 0;
for (int i = int(0); i <= int((1 << 20) - 1); i++) {
if (__builtin_parity(i)) {
add(ans, MO - pw[cnt[i]]);
} else {
add(ans, pw[cnt[i]]);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T read(T& x) {
x = 0;
int f = 0;
char ch = getchar();
while (ch < '0' || ch > '9') f |= (ch == '-'), ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x = f ? -x : x;
}
const int N = 1e6 + 10;
const int P = 1e9 + 7;
int n, i, status, ans, a[N], f[(1 << 20) + 10];
int fexp(int a, int n) {
int res = 1;
while (n) {
if (n & 1) res = 1LL * res * a % P;
a = 1LL * a * a % P;
n >>= 1;
}
return res;
}
inline void up(int& a, int b) {
a += b;
if (a >= P) a -= P;
}
int main() {
read(n);
for (i = 1; i <= n; i++) {
read(a[i]);
f[a[i]]++;
}
for (i = 0; i < 20; i++) {
for (status = 0; status < (1 << 20); status++) {
if (!(status & (1 << i))) f[status] += f[status | (1 << i)];
}
}
for (status = 0; status < (1 << 20); status++) {
int g = __builtin_popcount(status);
int res = fexp(2, f[status]) - 1;
if (res < 0) res += P;
if (g & 1)
up(ans, P - res);
else
up(ans, res);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, M = 21, MX = 1 << (M - 1), NX = 1e9 + 7;
int n, r, t, c, A[N], P[N], dp[M][1 << M];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &A[i]), dp[0][A[i]]++;
P[0] = 1;
for (int i = 1; i <= n; i++) P[i] = P[i - 1] * 2 % NX;
for (int i = 1; i < M; i++)
for (int j = 0; j < MX; j++) {
dp[i][j] = dp[i - 1][j];
if (!(j & (1 << (i - 1)))) dp[i][j] += dp[i - 1][j + (1 << (i - 1))];
}
for (int j = 0; j < MX; j++) {
if (__builtin_popcount(j) & 1)
c = (c - P[dp[M - 1][j]] + NX) % NX;
else
c = (c + P[dp[M - 1][j]]) % NX;
}
return !printf("%d", c);
}
|
#include <bits/stdc++.h>
using namespace std;
inline 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 << 3) + (x << 1) + (c ^ '0'), c = getchar();
return x * f;
}
const int N = 1 << 21, mod = 1e9 + 7, S = 1 << 20;
inline int inc(int x, int y) {
x += y - mod;
return x + (x >> 31 & mod);
}
inline void Inc(int &x, int y) {
x += y - mod;
x += (x >> 31 & mod);
}
inline void Del(int &x, int y) {
x -= y;
x += (x >> 31 & mod);
}
int n, f[N], cnt[N], bit[N], ans;
int main() {
n = read();
bit[0] = 1;
for (int i = 1; i <= n; i++) bit[i] = inc(bit[i - 1], bit[i - 1]);
for (int i = 1; i <= n; i++) f[read()]++;
for (int i = 0; i < 20; i++)
for (int s = 0; s < S; s++)
if (s >> i & 1) f[s ^ (1 << i)] += f[s];
ans = bit[n] - 1;
for (int i = 1; i < S; i++) {
cnt[i] = cnt[i >> 1] + (i & 1);
(cnt[i] & 1) ? Del(ans, bit[f[i]] - 1) : Inc(ans, bit[f[i]] - 1);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[21][1 << 20];
long long mod_pow(long long a, int b) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % 1000000007;
a = a * a % 1000000007;
b >>= 1;
}
return ret;
}
int main() {
int n, x;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &x);
++dp[0][x];
}
for (int i = 0; i <= 19; ++i) {
for (int mask = 0; mask < (1 << 20); ++mask) {
dp[i + 1][mask] += dp[i][mask];
if (dp[i + 1][mask] >= 1000000007) dp[i + 1][mask] -= 1000000007;
if (mask & (1 << i)) {
dp[i + 1][mask ^ (1 << i)] += dp[i][mask];
if (dp[i + 1][mask ^ (1 << i)] >= 1000000007)
dp[i + 1][mask ^ (1 << i)] -= 1000000007;
}
}
}
int ans = 0;
for (int mask = 0; mask < (1 << 20); ++mask) {
if (__builtin_popcount(mask) % 2 == 0) {
ans += mod_pow(2, dp[20][mask]);
if (ans >= 1000000007) ans -= 1000000007;
} else {
ans -= mod_pow(2, dp[20][mask]);
if (ans < 0) ans += 1000000007;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int DX[] = {1, 0, -1, 0, 1, -1, 1, -1};
const int DY[] = {0, 1, 0, -1, 1, -1, -1, 1};
const long long mod = 1000000007;
const int maxn = (int)(1 << 20) + 10;
const int M = 21;
int n;
long long a[maxn], f[maxn][M + 5], g[maxn], pow2[maxn];
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout << fixed;
cin >> n;
int _;
for (int i = 1; i < n + 1; i++) {
cin >> _;
a[_]++;
}
for (int x = 0; x < (1 << 20); x++) {
f[x][0] = a[x];
}
for (int i = 1; i < M; i++) {
for (int x = 0; x < (1 << 20); x++) {
if ((x >> (i - 1)) & 1)
f[x][i] = f[x][i - 1];
else
f[x][i] = f[x][i - 1] + f[x | (1 << (i - 1))][i - 1];
}
}
if (0)
for (int i = 0; i < 5; i++) {
for (int x = 0; x < (1 << 4); x++) {
cerr << f[x][i] << ' ';
}
cerr << endl;
}
pow2[0] = 1;
for (int i = 1; i < (1 << 20); i++) {
pow2[i] = (2 * pow2[i - 1]) % mod;
}
long long ans = 0;
for (int x = 0; x < (1 << 20); x++) {
ans += ((__builtin_popcount(x) & 1) ? -1 : 1) * pow2[f[x][20]];
while (ans < 0) ans += mod;
ans %= mod;
}
cout << ans << endl;
if (0) cerr << "time = " << clock() * 1.0 / CLOCKS_PER_SEC << " s" << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int MAXN = 1e6 + 10;
const long long MOD = 1e9 + 7;
const long long MOD2 = 998244353;
const long long INF = 8e18;
const int LOG = 22;
long long pw(long long a, long long b, long long mod) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % mod, b / 2, mod)) % mod
: pw(a * a % mod, b / 2, mod)));
}
int v[MAXN], dp[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> v[i];
dp[v[i]]++;
}
for (int i = 0; i < LOG; i++) {
for (int mask = MAXN - 1; ~mask; mask--) {
if (mask & (1 << i)) {
dp[mask ^ (1 << i)] += dp[mask];
}
}
}
long long ans = 0;
for (int mask = 0; mask < MAXN; mask++) {
int f = __builtin_popcount(mask);
int z = ((f % 2) ? -1 : 1);
ans = (ans + z * pw(2, dp[mask], MOD) + MOD) % MOD;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int N = 20;
const int M = 1000005;
int n, ans = 0;
int F[M], a[M];
void calculateF() {
for (int i = 0; i < N; i += 1) {
for (int mask = M; mask >= 0; mask -= 1) {
if (mask & (1 << i)) {
(F[1 << i ^ mask] += F[mask]) %= 1000000007;
}
}
}
for (int i = M; i >= 0; i -= 1) {
(ans += 1ll * (__builtin_popcount(i) % 2 ? -1 : 1) * (a[F[i]] - 1)) %=
1000000007;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
memset(F, (0), sizeof(F));
memset(a, (0), sizeof(a));
for (int i = 0; i < n; i += 1) {
int x;
cin >> x;
F[x]++;
}
a[0] = 1;
for (int i = 0; i < n + 1; i += 1) {
if (i == 0) continue;
a[i] = (a[i - 1] << 1) % 1000000007;
}
calculateF();
cout << ((ans + 1000000007) % 1000000007);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:500000000")
using namespace std;
const int mod = 1000000007;
int a[(1 << 20)], t2[(1 << 20) + 1], bitCount[(1 << 20)], c[(1 << 20)];
int main() {
int n, i;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
c[a[i]]++;
}
t2[0] = 1;
for (i = 1; i <= (1 << 20); i++) t2[i] = t2[i - 1] * 2 % mod;
bitCount[1] = 1;
for (i = 2; i < (1 << 20); i++) bitCount[i] = bitCount[i / 2] + (i & 1);
for (int bit = 20 - 1; bit >= 0; bit--)
for (int mask = 0; mask < (1 << 20); mask++)
if (mask & (1 << bit)) c[mask ^ (1 << bit)] += c[mask];
long long res = (t2[n] - 1 + mod) % mod;
for (int mask = 1; mask < (1 << 20); mask++) {
if (bitCount[mask] & 1)
res = (res - (t2[c[mask]] - 1) + mod) % mod;
else
res = (res + (t2[c[mask]] - 1) + mod) % mod;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int ar[1048600];
int dp[1048600][21];
long long pow2[1048600];
int func(int x, int bit) {
if (bit == -1) {
return ar[x];
}
if (dp[x][bit] != -1) return dp[x][bit];
int z = x & (1 << bit);
int ans = 0;
if (z) {
ans = func(x, bit - 1);
} else {
ans = func(x, bit - 1) + func(x | (1 << bit), bit - 1);
}
return dp[x][bit] = ans;
}
int ff(int x) { return func(x, 19); }
void solve() {
int n;
cin >> n;
memset(dp, -1, sizeof(dp));
;
memset(ar, 0, sizeof(ar));
;
for (int i = 0; i < (int)(n); i++) {
int x;
cin >> x;
ar[x]++;
}
int mask = 1 << 20;
long long ans = 0;
pow2[0] = 1;
for (int i = 1; i < 1000005; i++) {
pow2[i] = (pow2[i - 1] * 2) % 1000000007;
}
while (mask > 0) {
mask--;
long long z = pow2[ff(mask)];
int cnt = 0;
int m = mask;
while (m > 0) {
if (m & 1) cnt = !cnt;
m >>= 1;
}
if (cnt) z = (-z + 1000000007) % 1000000007;
ans = (ans + z) % 1000000007;
}
cout << ans;
}
int main() {
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
int TC = 1;
for (int ZZ = 1; ZZ <= TC; ZZ++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
const int B = 20;
long long mod = 1e9 + 7;
long long po[N];
long long f[N];
int main() {
int n;
scanf("%d", &n);
po[0] = 1;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
f[x]++;
po[i] = (po[i - 1] << 1) % mod;
}
for (int i = 0; i < B; i++)
for (int mask = 0; mask < (1 << B); mask++)
if (!(mask & (1 << i))) f[mask] += f[mask ^ (1 << i)];
long long ans = 0;
for (int mask = 1; mask < (1 << B); mask++) {
long long cur = po[f[mask]] - 1 + mod;
cur %= mod;
int cnt = __builtin_popcount(mask);
if (!(cnt & 1)) cur = mod - cur;
ans = (ans + cur) % mod;
}
ans = po[n] - 1 + mod - ans;
ans %= mod;
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3fLL;
ll modpow(ll x, ll p, ll mod) {
x %= mod, (p %= mod - 1) < 0 ? p += mod - 1 : 0LL;
ll res = 1LL;
while (p > 0) {
if (p & 1) res = res * x % mod;
(x *= x) %= mod, p >>= 1;
}
return res;
}
template <int mod>
struct Mint {
int x;
Mint(ll x = 0) : x(int((x %= mod) < 0 ? x + mod : x)) {}
Mint& operator+=(const Mint& rhs) {
if ((x += rhs.x) >= mod) x -= mod;
return *this;
}
Mint& operator-=(const Mint& rhs) { return *this += mod - rhs.x; }
Mint& operator*=(const Mint& rhs) {
x = int((1LL * x * rhs.x) % mod);
return *this;
}
Mint& operator/=(const Mint& rhs) {
return *this *= Mint(modpow(rhs.x, mod - 2, mod));
}
Mint operator+(const Mint& rhs) const { return Mint(*this) += rhs; }
Mint operator-(const Mint& rhs) const { return Mint(*this) -= rhs; }
Mint operator*(const Mint& rhs) const { return Mint(*this) *= rhs; }
Mint operator/(const Mint& rhs) const { return Mint(*this) /= rhs; }
Mint power(ll p) const { return Mint(modpow(x, p, mod)); }
bool operator==(const Mint& rhs) const { return x == rhs.x; }
bool operator<(const Mint& rhs) const { return x < rhs.x; }
friend ostream& operator<<(ostream& out, const Mint& a) { return out << a.x; }
friend istream& operator>>(istream& in, Mint& a) {
ll x;
in >> x;
a = Mint(x);
return in;
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
constexpr int mod = 1e9 + 7, N = 20, fullmask = (1 << N) - 1;
using Mi = Mint<mod>;
vector<Mi> F(1 << N, 1);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
F[fullmask ^ a] *= Mi(2);
}
for (int i = 0; i < N; ++i)
for (int mask = 0; mask < (1 << N); ++mask)
if (mask >> i & 1) F[mask] *= F[mask ^ (1 << i)];
vector<int> sgn(1 << N);
sgn[0] = (N % 2 ? -1 : +1);
Mi ans = F[0] * sgn[0];
for (int mask = 1; mask < (1 << N); ++mask) {
sgn[mask] = -sgn[mask & (mask - 1)];
ans += F[mask] * sgn[mask];
}
cout << ans << '\n';
exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long inf = 1e9;
const long long N = (1 << 20);
long long mod_expo(long long a, long long b, long long c) {
long long ans = 1;
while (b) {
if (b & (long long)1) ans = (ans * a) % c;
a = (a * a) % c;
b = b >> 1;
}
return ans;
}
long long inverse(long long n) { return mod_expo(n, mod - 2, mod); }
int n;
int total;
int a[N];
long long f[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
total = 1 << 20;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a[x]++;
}
n = 20;
for (int i = 0; i < total; i++) f[i] = a[i];
for (int i = 0; i < n; i++) {
for (int mask = total - 1; mask >= 0; mask--) {
if ((mask & (1 << i)) == 0) f[mask] += f[mask ^ (1 << i)];
}
}
long long ans = 0;
for (int i = 0; i < total; i++) {
int bits = __builtin_popcount(i);
if (bits % 2)
ans -= mod_expo(2, f[i], mod);
else
ans += mod_expo(2, f[i], mod);
ans %= mod;
ans += mod;
ans %= mod;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, z[1 << 20], p[1000005], ans, a;
int main(void) {
scanf("%I64d", &n);
for (int i = 0; i < n; i++) {
scanf("%I64d", &a);
z[a]++;
}
p[0] = 1;
for (int i = 1; i <= n; i++) p[i] = p[i - 1] * 2LL % 1000000007;
for (int i = 0; i < 20; i++)
for (int j = 0; j < 1 << 20; j++)
if (!(j >> i & 1)) z[j] += z[j | (1 << i)];
for (int i = 0; i < 1 << 20; i++) {
a = 0;
for (int j = 0; j < 20; j++)
if (i >> j & 1) a++;
if (a % 2)
ans = (ans + 1000000007 - p[z[i]]) % 1000000007;
else
ans = (ans + p[z[i]]) % 1000000007;
}
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007, m = 1 << 20;
int n, f[m + 10], two[m + 10], ans;
void work() {
scanf("%d", &n);
for (int i = 1, x; i <= n; i++) scanf("%d", &x), f[x]++;
for (int i = 0; i < 20; i++)
for (int j = 0; j < m; j++)
if (j & (1 << i)) f[j ^ (1 << i)] += f[j];
two[0] = 1;
for (int i = 1; i <= n; i++) two[i] = (two[i - 1] << 1) % mo;
for (int i = 0; i < m; i++) {
int x = i, p = 0;
while (x) p += x & 1, x >>= 1;
if (p & 1)
ans = (ans - two[f[i]] + mo) % mo;
else
ans = (ans + two[f[i]]) % mo;
}
printf("%d", ans);
}
int main() {
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const int V = (1 << 20) + 10;
const int P = 1000000007;
int Pow(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = (long long)ret * x % P;
x = (long long)x * x % P;
y /= 2;
}
return ret;
}
void utf(int *a, int l, int r) {
if (l + 1 != r) {
int mid = (l + r) / 2;
for (int i = 0; i < mid - l; i++) {
a[l + i] -= a[mid + i];
if (a[l + i] < 0) a[l + i] += P;
}
utf(a, l, mid);
utf(a, mid, r);
}
}
void tf(int *a, int l, int r) {
if (l + 1 != r) {
int mid = (l + r) / 2;
tf(a, l, mid);
tf(a, mid, r);
for (int i = 0; i < mid - l; i++) {
a[l + i] += a[mid + i];
if (a[l + i] >= P) a[i + l] -= P;
}
}
}
int cnt[V], q[V];
int n, x, pro[V];
int pt[V];
int main() {
pt[0] = 1;
for (int i = 1; i < (1 << N); i++) pt[i] = pt[i - 1] * 2 % P;
while (~scanf("%d", &n)) {
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n; i++) {
scanf("%d", &x);
cnt[x]++;
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < (1 << N); j++) {
if (j & (1 << i)) {
cnt[j ^ (1 << i)] += cnt[j];
if (cnt[j ^ (1 << i)] >= P) {
cnt[j ^ (1 << i)] -= P;
}
}
}
}
for (int i = 0; i < (1 << N); i++) pro[i] = pt[cnt[i]];
for (int i = N - 1; i >= 0; i--) {
for (int j = (1 << N); j >= 0; j--) {
if (j & (1 << i)) {
pro[j ^ (1 << i)] += P - pro[j];
if (pro[j ^ (1 << i)] >= P) {
pro[j ^ (1 << i)] -= P;
}
}
}
}
pro[0] = (pro[0] % P + P) % P;
printf("%d\n", pro[0]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
char ch = getchar();
int f = 1;
while ((ch != '-') && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-')
f = -1, x = 0;
else
x = ch - 48;
ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - 48, ch = getchar();
x *= f;
}
void read(long long &x) {
char ch = getchar();
int f = 1;
while ((ch != '-') && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-')
f = -1, x = 0;
else
x = ch - 48;
ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10LL + ch - 48, ch = getchar();
x *= f;
}
void _print(const int &x) {
if (x < 10)
putchar(48 + x);
else
_print(x / 10), _print(x % 10);
}
void _print(const long long &x) {
if (x < 10)
putchar(48 + x);
else
_print(x / 10), _print(x % 10);
}
void print(const int &x) {
if (x < 0)
putchar('-'), _print(-x);
else
_print(x);
}
void print(const long long &x) {
if (x < 0)
putchar('-'), _print(-x);
else
_print(x);
}
void println(const int &x) {
print(x);
putchar('\n');
}
void println(const long long &x) {
print(x);
putchar('\n');
}
int n, x, a[1 << 20], p2[1 << 20];
int main() {
read(n);
p2[0] = 1;
for (int i = (1); i <= (n); i++)
read(x), a[x]++, p2[i] = 1ll * p2[i - 1] * 2 % 1000000007;
for (int i = (0); i <= (19); i++)
for (int j = (0); j <= ((1 << 20) - 1); j++)
if (!(j & 1 << i)) a[j] += a[j + (1 << i)];
int ans = 0;
for (int i = (0); i <= ((1 << 20) - 1); i++)
if (__builtin_popcount(i) & 1)
ans = (ans - p2[a[i]]) % 1000000007;
else
ans = (ans + p2[a[i]]) % 1000000007;
println((ans + 1000000007) % 1000000007);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20) + 100;
bool one(int mask, int i) { return mask & (1 << i); }
int mod = 1000000007;
int n, a[N], d[N];
int p[N];
int cnt[N];
int was[N];
int main() {
scanf("%d", &n);
p[0] = 1;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
p[i] = p[i - 1] << 1;
if (p[i] >= mod) p[i] -= mod;
d[a[i]]++;
}
for (int i = 0; i <= n; ++i) --p[i];
for (int i = 20; i >= 0; --i)
for (int j = (1 << i); j < (1 << 20); ++j)
if (one(j, i)) d[j - (1 << i)] += d[j];
long long ans = 0;
for (int i = 1; i <= 1000000; ++i) {
if (!d[i]) continue;
int kol = __builtin_popcount(i);
if (kol & 1)
ans = (ans + p[d[i]]) % mod;
else
ans = (ans - p[d[i]] + mod) % mod;
}
ans = (p[n] - ans) % mod;
ans = (ans + mod) % mod;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
long long mo = 1000000007;
long long dp[(1 << 20) + 5][25];
vector<long long> f, f1, f2;
long long power(long long x, unsigned long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
vector<long long> sos(vector<long long> &v) {
vector<long long> ans = v;
for (long long i = 0; i < n; i++) {
for (long long mask = 0; mask < (1 << n); mask++) {
if (mask >> i & 1) {
ans[mask] += ans[mask ^ (1 << i)];
ans[mask] %= mo;
}
}
}
return ans;
}
vector<long long> combine(vector<long long> &a) {
memset(dp, 0, sizeof(dp));
vector<long long> ans(1 << n, 0);
for (long long i = 0; i < (1 << n); i++) ans[i] = power(2, a[i], mo);
for (long long mask = 0; mask < (1 << n); mask++) {
dp[mask][-1] = 0;
for (long long i = 0; i < n; i++) {
dp[mask][i] = dp[mask][i - 1];
if (mask >> i & 1) {
dp[mask][i] += dp[mask ^ (1 << i)][i - 1];
dp[mask][i] %= mo;
}
}
ans[mask] = (ans[mask] - dp[mask][n - 1] + mo) % mo;
dp[mask][-1] = ans[mask];
for (long long i = 0; i < n; i++) {
dp[mask][i] = dp[mask][i - 1];
if (mask >> i & 1) {
dp[mask][i] += dp[mask ^ (1 << i)][i - 1];
dp[mask][i] %= mo;
}
}
}
return ans;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long m;
cin >> m;
n = 20;
long long k = (1 << n);
k--;
f = f1 = f2 = vector<long long>(1 << n, 0);
for (long long i = 0; i < m; i++) {
long long x1;
cin >> x1;
x1 ^= k;
f[x1]++;
}
long long req = 0;
f1 = sos(f);
f2 = combine(f1);
cout << f2[k];
}
|
#include <bits/stdc++.h>
int FASTBUFFER;
using namespace std;
const int N = 1048576;
const int mo = 1000000007;
int dp[N * 2 + 5];
int mi[N + 5], fac[N + 5];
int n, ans;
int main() {
scanf("%d", &n);
mi[0] = 1;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
dp[x]++;
mi[i] = (mi[i - 1] + mi[i - 1]) % mo;
}
for (int i = 1; i < N; i <<= 1) {
for (int j = 0; j < N; j++) {
if (i & j) {
dp[i ^ j] += dp[j];
}
}
}
ans = mi[n];
fac[0] = 1;
for (int i = 1; i < N; i++) {
fac[i] = -fac[i - (i & (0 - i))];
(ans += fac[i] * mi[dp[i]]) %= mo;
}
while (ans < 0) {
ans += mo;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int INF = 0x3f3f3f3f, N = 1e6 + 5, bit = 20, mod = 1e9 + 7;
int n, a[N];
ll dp[N << 1];
ll powmod(ll a, ll b, ll mod) {
ll ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
dp[a[i]]++;
}
for (int i = 0; i < bit; i++) {
for (int mask = 0; mask < (1 << bit); mask++) {
if (mask & (1 << i))
dp[mask ^ (1 << i)] = (dp[mask ^ (1 << i)] + dp[mask]) % mod;
}
}
ll ans = 0;
for (int i = 0; i < (1 << bit); i++) {
int cnt = __builtin_popcount(i);
if (cnt & 1)
ans = (ans - powmod(2, dp[i], mod) + 1 + mod) % mod;
else
ans = (ans + powmod(2, dp[i], mod) - 1 + mod) % mod;
}
cout << (ans + mod) % mod << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int ra, fh;
char rx;
rx = getchar(), ra = 0, fh = 1;
while ((rx < '0' || rx > '9') && rx != '-') rx = getchar();
if (rx == '-') fh = -1, rx = getchar();
while (rx >= '0' && rx <= '9') ra *= 10, ra += rx - 48, rx = getchar();
return ra * fh;
}
int n, x, dp[3000000], g[3000000];
long long f[3000000];
long long ans = 0;
int main() {
scanf("%d", &n);
int mx = (1 << 20) - 1;
for (int i = 1; i <= n; i++) {
x = read();
dp[x]++;
}
f[0] = 1;
for (int i = 1; i <= n; i++) f[i] = (f[i - 1] << 1) % 1000000007;
for (int i = 1; i <= 20; i++)
for (int j = 0; j <= mx; j++)
if (j & (1 << i - 1)) {
dp[j ^ (1 << i - 1)] += dp[j];
}
ans = f[n] - 1;
for (int i = 1; i <= mx; i++) {
g[i] = g[i >> 1] + (1 & i);
if (g[i] & 1)
ans = (ans - f[dp[i]] + 1 + 1000000007) % 1000000007;
else
ans = (ans + f[dp[i]] - 1 + 1000000007) % 1000000007;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007;
const int N = (1 << 20) + 5;
int f[N], g[N];
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
g[0] = 1;
for (int i = 1; i <= (1 << 20); ++i) g[i] = g[i - 1] * 2 % mo;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
++f[x];
}
for (int j = 1; j < (1 << 20); j <<= 1)
for (int i = 0; i < (1 << 20); ++i)
if (i & j) f[i ^ j] += f[i];
for (int i = 1; i < (1 << 20); ++i) f[i] = g[f[i]];
int ans = 0;
for (int j = 1; j < (1 << 20); j <<= 1)
for (int i = 0; i < (1 << 20); ++i)
if (i & j) (f[i ^ j] -= f[i]) %= mo;
for (int i = 1; i < (1 << 20); ++i) (ans += f[i]) %= mo;
(ans = g[n] - ans) %= mo;
if (ans < 0) ans += mo;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 28;
const int mod = (int)1e9 + 7;
int n, m, k;
int dp[1 << 20];
long long p[1000010];
int main() {
cin >> n;
int x;
p[0] = 1;
for (int i = 1; i <= n; i++) {
p[i] = p[i - 1] * 2 % mod;
scanf("%d", &x);
dp[x]++;
}
for (int i = 0; i < 20; i++) {
for (int j = 0; j < (1 << 20); j++) {
if (j >> i & 1) dp[j - (1 << i)] += dp[j];
}
}
long long ans = p[n];
for (int i = 1; i < (1 << 20); i++) {
int num = __builtin_popcount(i);
if (num & 1)
ans += mod - p[dp[i]];
else
ans += p[dp[i]];
if (ans >= mod) ans -= mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int xx = 0, ff = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') ff = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
xx = xx * 10 + ch - '0';
ch = getchar();
}
return xx * ff;
}
inline int lowbit(int x) { return x & -x; }
const int MOD = 1000000007, maxn = 2000010;
int N, a[maxn], f[maxn], cnt[maxn];
int mypow(int a, int b) {
int re = 1;
while (b) {
if (b & 1) re = 1LL * re * a % MOD;
b >>= 1;
a = 1LL * a * a % MOD;
}
return re;
}
int get_cnt(int x) {
int re = 0;
while (x) {
x -= lowbit(x);
re++;
}
return re;
}
int main() {
N = read();
for (int i = 1; i <= N; i++) f[read()]++;
for (int i = 0; i <= 19; i++)
for (int j = 0; j <= 1000000; j++)
if (j & (1 << i)) (f[j ^ (1 << i)] += f[j]) % MOD;
for (int i = 0; i <= 1000000; i++) cnt[i] = get_cnt(i);
int ans = 0;
for (int i = 0; i <= 1000000; i++)
if (cnt[i] & 1)
ans = (1LL * ans - (mypow(2, f[i]) - 1)) % MOD;
else
ans = (1LL * ans + (mypow(2, f[i]) - 1)) % MOD;
if (ans < 0) ans += MOD;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int block = 400;
const long long base = 31, base2 = 37;
const long long mod = 1e9 + 7, mod2 = 1e9 + 9;
int a[1000011], n, freq[(1 << 22) + 10];
long long f[(1 << 22) + 10];
long long quickPow(int x, int y) {
if (y == 0) return 1;
long long tmp = quickPow(x, y / 2) % mod;
if (y % 2) return (((tmp * tmp) % mod) * x) % mod;
return (tmp * tmp) % mod;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
f[a[i]]++;
}
long long ans = 0;
for (int j = 0; j <= 20; j++) {
for (int mask = 0; mask <= 1e6; mask++) {
if ((mask & (1 << j)) == 0) {
f[mask] = (f[mask] + f[mask + (1 << j)]) % mod;
assert(mask + (1 << j) < (1 << 22));
assert(f[mask] >= 0);
}
}
}
for (int i = 0; i < (1 << 20); i++) {
long long mul = 1;
if (__builtin_popcount(i) % 2 == 1) mul = -1;
ans = (ans + ((mul * quickPow(2, f[i])) % mod)) % mod;
ans = (ans + mod * mod) % mod;
if (ans < 0) {
break;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, f[1 << 20];
int POW[1000009];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
f[x]++;
}
for (int i = 1; i <= 20; i++)
for (int j = 0; j < 1 << 20; j++) {
if ((j & (1 << (i - 1))) == 0) f[j] += f[j + (1 << (i - 1))];
}
POW[0] = 1;
for (int i = 1; i <= n; i++) POW[i] = (long long)POW[i - 1] * 2 % 1000000007;
long long ans = POW[n];
for (int i = 1; i < (1 << 20); i++) {
int cnt = 0;
for (int j = 0; j < 20; j++) {
if (i & (1 << j)) cnt++;
}
if (cnt % 2 == 1)
ans -= POW[f[i]];
else
ans += POW[f[i]];
ans %= 1000000007;
ans += 1000000007;
ans %= 1000000007;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int a[2000009];
long long int fac[2000009];
long long int power(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = res * x;
res %= 1000000007;
y = y >> 1;
x = x * x;
x %= 1000000007;
}
return res;
}
long long int inv(long long int x) { return power(x, 1000000007 - 2); }
long long int ncr(long long int n, long long int r) {
long long int res = fac[n];
res *= inv(fac[r]);
res %= 1000000007;
res *= inv(fac[n - r]);
res %= 1000000007;
return res;
}
void solve() {
long long int n;
cin >> n;
fac[0] = 1;
for (long long int i = 1; i <= n; i++) {
fac[i] = fac[i - 1] * i;
fac[i] %= 1000000007;
}
long long int p = power(2, 19);
long long int x;
for (long long int i = 0; i < n; i++) {
cin >> x;
a[x]++;
}
long long int ans = power(2, n);
ans--;
long long int z = power(2, 20);
z--;
for (long long int j = 0; j < 20; j++) {
long long int b = 0;
for (long long int i = 1; i <= z; i++) {
long long int x = i | ((long long int)1 << j);
if (x != i) a[i] += a[x];
}
}
for (long long int i = z; i > 0; i--) {
long long int b = 0;
for (long long int j = 0; j < 20; j++) {
long long int x = i | ((long long int)1 << j);
if (x == i) b++;
}
long long int t = power(2, a[i]);
t--;
t %= 1000000007;
if (b % 2 == 0) {
ans += t;
} else {
ans -= t;
ans %= 1000000007;
ans += 1000000007;
}
ans %= 1000000007;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
for (long long int i = 0; i < t; i++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e6 + 10;
const int mod = 1e9 + 7;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
void FWT(int *a, int n) {
for (int i = 1; i < n; i <<= 1)
for (int p = i << 1, j = 0; j < n; j += p)
for (int k = 0; k < i; k++) {
int x = a[j + k], y = a[j + k + i];
a[j + k + i] = x + y;
}
}
void IFWT(int *a, int n) {
for (int i = 1; i < n; i <<= 1)
for (int p = i << 1, j = 0; j < n; j += p)
for (int k = 0; k < i; k++) {
int x = a[j + k], y = a[j + k + i];
a[j + k + i] = y - x;
}
}
int n, maxn = 0, a[N], f[N], g[N];
int q_pow(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
return ret;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) a[i] = gi(), f[a[i]]++, maxn = max(maxn, a[i]);
int N;
for (N = 1; N <= maxn; N <<= 1)
;
for (int i = 0; i < N; i++) g[i] = f[(~i) & (N - 1)];
FWT(g, N);
for (int i = 0; i < N; i++) f[i] = g[(~i) & (N - 1)];
int ans = 0;
for (int i = 1; i < N; i++)
ans = ((ans + q_pow(-1, __builtin_popcount(i) + 1) * (q_pow(2, f[i]) - 1)) %
mod +
mod) %
mod;
ans = ((q_pow(2, n) - 1 - ans) % mod + mod) % mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 20) + 1e5;
const long long mode = 1e9 + 7;
int dp[maxn];
long long powerFun(int fi, int se) {
if (se == 0) return 1;
long long ret = powerFun(fi, se / 2);
ret = (ret * ret) % mode;
if (se % 2 == 0)
return ret;
else
return (ret * 2) % mode;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
dp[x]++;
}
for (int i = 0; i < 20; i++)
for (int mask = (1 << 20) - 1; mask >= 0; mask--)
if (mask & (1 << i)) dp[mask ^ (1 << i)] += dp[mask];
long long ans = powerFun(2, n);
for (int mask = 1; mask < (1 << 20); mask++) {
if (__builtin_popcount(mask) % 2 == 1)
ans -= powerFun(2, dp[mask]);
else
ans += powerFun(2, dp[mask]);
if (ans >= mode) ans -= mode;
if (ans < 0) ans += mode;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void Int(T &n) {
n = 0;
int f = 1;
int ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) n = (n << 3) + (n << 1) + ch - '0';
n = n * f;
}
template <typename T>
T gcd(T a, T b) {
return !b ? a : gcd(b, a % b);
}
template <typename T>
inline void umin(T &a, T b) {
a = a < b ? a : b;
}
template <typename T>
inline void umax(T &a, T b) {
a = a > b ? a : b;
}
template <typename T, typename W>
inline void Int(T &x, W &y) {
Int(x), Int(y);
}
template <typename T, typename W, typename Q>
inline void Int(T &x, W &y, Q &z) {
Int(x, y), Int(z);
}
const int N = 1e6 + 7;
const int inf = 1e9 + 7;
const int magic = 20;
int solve() {
int n;
Int(n);
vector<int> dp(1 << magic);
for (int i = 0; i < n; ++i) {
int x;
Int(x);
++dp[x];
}
for (int i = 0; i < magic; ++i) {
for (int mask = 0; mask < (1 << magic); ++mask) {
if ((mask >> i & 1) == 0) {
dp[mask] += dp[mask | (1 << i)];
}
}
}
vector<long long> pw(n + 1);
pw[0] = 1;
for (int i = 1; i <= n; ++i) {
pw[i] = (pw[i - 1] * 2) % 1000000007LL;
}
long long res = 0;
for (int mask = 0; mask < (1 << magic); ++mask) {
int x = (__builtin_popcount(mask) & 1) ? -1 : 1;
res = (res + pw[dp[mask]] * x + 1000000007LL) % 1000000007LL;
}
printf("%lld\n", res);
return 0;
}
int main() {
int tests = 1, CaseNo = 0;
while (tests--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 7, mod = 1e9 + 7, Lg = 20;
inline int add(int a, int b) {
int c = a + b;
if (c >= mod) c -= mod;
return c;
}
int t[N], a[N];
int tav[N];
int main() {
tav[0] = 1;
for (int i = 1; i < N; i++) tav[i] = add(tav[i - 1], tav[i - 1]);
ios::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
t[a[i]]++;
}
for (int i = Lg - 1; i >= 0; i--)
for (int mask = 0; mask < (1 << Lg); mask++)
if (((mask >> i) & 1) == 0) t[mask] = add(t[mask], t[mask ^ (1 << i)]);
int ans = 0;
for (int i = 0; i < (1 << Lg); i++)
if (__builtin_popcount(i) & 1)
ans = add(ans, -tav[t[i]] + mod);
else
ans = add(ans, tav[t[i]]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = (1 << 20) + 5;
const int mod = 1e9 + 7;
int n, i, j, x, lim, sol;
int f[nmax], cnt[nmax], two[nmax];
void fix(int &x) {
if (x < 0) x += mod;
if (x >= mod) x -= mod;
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &x);
f[x]++;
}
lim = 1 << 20;
two[0] = 1;
for (i = 1; i < lim; i++) two[i] = (two[i - 1] * 2) % mod;
for (i = 0; i < 20; i++)
for (j = 0; j < lim; j++) {
if ((1 << i) & j)
cnt[j]++;
else
f[j] += f[j + (1 << i)];
}
for (i = 1; i < lim; i++) {
if (cnt[i] & 1) {
sol += two[f[i]] - 1;
fix(sol);
} else {
sol -= two[f[i]] - 1;
fix(sol);
}
}
sol = two[n] - 1 - sol;
fix(sol);
printf("%d\n", sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
auto Random_Address = [] {
char* c;
c = new char;
delete c;
return uint64_t(c);
};
uint64_t const SEED = chrono::steady_clock::now().time_since_epoch().count() *
(Random_Address() bitor 1);
mt19937 Rng(SEED);
constexpr int Mask(int i) { return 1 << i; }
constexpr int Getb(int x, int i) { return x >> i bitand 1; }
template <size_t N>
bitset<N> Bits(int x) {
return bitset<N>(x);
}
template <class X, class Y>
bool minimize(X& x, Y const& y) {
return y < x ? x = y, 1 : 0;
}
template <class X, class Y>
bool maximize(X& x, Y const& y) {
return y > x ? x = y, 1 : 0;
}
int constexpr maxN = 1e6, mod_ = 1e9 + 7, maxA = 1e6;
int constexpr maxB = 20;
int N;
int a[maxN + 3];
int f[Mask(maxB) + 3];
int main() {
cin.tie(nullptr)->sync_with_stdio(false);
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> a[i];
++f[a[i]];
}
for (int j = 0; j < maxB; j++)
for (int i = Mask(maxB) - 1; i >= 0; i--)
if (Getb(i, j)) f[i xor Mask(j)] += f[i];
auto Add = [](int& x, int const& y) {
x += y;
if (x >= mod_) x -= mod_;
return;
};
auto Sub = [](int& x, int const& y) {
x -= y;
if (x < 0) x += mod_;
return;
};
auto Mul = [](int const& x, int const& y) {
return static_cast<int>(static_cast<int64_t>(x) * y % mod_);
};
auto Pow = [](int x, int y) {
int res = 1;
for (; y; y >>= 1, x = static_cast<int64_t>(x) * x % mod_)
if (y bitand 1) res = static_cast<int64_t>(res) * x % mod_;
return res;
};
int res = 0;
for (int i = 0; i < Mask(maxB); i++)
if (__builtin_popcount(i) bitand 1)
Sub(res, Pow(2, f[i]));
else
Add(res, Pow(2, f[i]));
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
const int N = 2000010;
int n, co[N], f[22][N], p2[N], m, k;
int parity(int n) {
int num = 0;
if (n) do
num ^= 1;
while (n &= n - 1);
return num;
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 1, x; i <= n; ++i) {
cin >> x;
co[x]++;
m = max(m, x);
}
k = 1;
while ((1 << k) <= m) ++k;
p2[0] = 1;
for (int i = 1; i <= n; ++i) p2[i] = (2 * p2[i - 1]) % M;
if (n == N - 10) {
cout << k << ' ' << m << '\n';
}
int ans = 0;
for (int c = (1 << k) - 1; c >= 0; --c) {
if (c & 1)
f[0][c] = co[c];
else
f[0][c] = co[c] + co[c ^ 1];
for (int i = 1; i < k; ++i)
if (c & (1 << i))
f[i][c] = f[i - 1][c];
else
f[i][c] = (f[i - 1][c] + f[i - 1][c ^ (1 << i)]) % M;
int sgn = parity(c);
if (sgn % 2)
sgn = -1;
else
sgn = 1;
ans = (1LL * ans + sgn * p2[f[k - 1][c]]) % M;
if (ans < 0) ans += M;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20) + 10;
const int MOD = 1000000007;
int num[N], n;
long long pow2[N];
void init() {
pow2[0] = 1;
for (int i = 1; i < N; ++i) {
pow2[i] = pow2[i - 1] * 2;
if (pow2[i] >= MOD) pow2[i] -= MOD;
}
}
int main() {
init();
scanf("%d", &n);
int x;
for (int i = 1; i <= n; ++i) {
scanf("%d", &x);
++num[x];
}
long long ans = 0;
for (int i = 0; i < 20; ++i) {
for (int j = (1 << 20) - 1; j; --j) {
if (j & (1 << i)) num[j - (1 << i)] += num[j];
}
}
for (int i = (1 << 20) - 1; i; --i) {
int k = __builtin_popcount(i);
if (k % 2)
ans += pow2[num[i]];
else
ans -= pow2[num[i]];
}
ans = pow2[n] - ans;
ans %= MOD;
if (ans < 0) ans += MOD;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1000000007;
int f[1 << 20];
int p[1 << 20];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
f[x] += 1;
}
for (int i = 1; i < (1 << 20); i *= 2) {
for (int j = (1 << 20) - 1; j >= 0; --j) {
if ((j & i) != 0) {
f[j ^ i] += f[j];
}
}
}
int ans = 0;
p[0] = 1;
for (int i = 1; i < (1 << 20); ++i) p[i] = (p[i - 1] * 2) % Mod;
for (int i = 0; i < (1 << 20); ++i) {
int cnt = __builtin_popcount(i);
if (cnt & 1)
ans -= p[f[i]];
else
ans += p[f[i]];
ans %= Mod;
}
ans += Mod, ans %= Mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mask[(1LL << 20)];
long long p[(1LL << 20)];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
;
long long n;
cin >> n;
long long a[n];
p[0] = 1;
for (long long i = 0; i < n; i++) {
cin >> a[i];
mask[a[i]]++;
if (i != 0) p[i] = (p[i - 1] * 2) % 1000000007;
}
p[n] = (p[n - 1] * 2) % 1000000007;
for (long long i = 0; i < 20; i++) {
for (long long j = 0; j < (1LL << 20); j++) {
if (!(j & (1 << i))) {
mask[j] += mask[j ^ (1 << i)];
}
}
}
for (long long i = 0; i < (1LL << 20); i++) {
mask[i] = (p[mask[i]] - 1 + 1000000007) % 1000000007;
}
for (long long i = 0; i < 20; i++) {
for (long long j = 0; j < (1LL << 20); j++) {
if (!(j & (1LL << i))) {
mask[j] = (mask[j] - mask[j ^ (1LL << i)] + 1000000007) % 1000000007;
}
}
}
cout << mask[0] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using ii = pair<int, int>;
const int oo = 0x3f3f3f3f;
const ll OO = ll(oo) * oo;
const int N = 1 << 20;
const ll M = 1000000007;
ll A[N];
ll f[N];
ll p2[N];
void add(ll& x, ll y) {
x += y;
if (x >= M) x -= M;
if (x < 0) x += M;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
f[A[i]]++;
}
p2[0] = 1;
for (int i = 1; i < N; i++) p2[i] = p2[i - 1] * 2 % M;
for (int b = 1; b < N; b <<= 1) {
for (int u = 0; u < N; u += (b << 1)) {
for (int l = 0; l < b; l++) {
add(f[u | l], f[u | l | b]);
}
}
}
for (int i = 0; i < N; i++) {
f[i] = p2[f[i]] - 1;
}
for (int b = 1; b < N; b <<= 1) {
for (int u = 0; u < N; u += (b << 1)) {
for (int l = 0; l < b; l++) {
add(f[u | l], -f[u | l | b]);
}
}
}
cout << f[0] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxK = 20;
const int maxN = (1 << maxK);
const int INF = (int)1e9;
const long long MOD = 7 + (long long)1e9;
const double eps = 1e-9;
int A[maxN];
int F[maxN];
int bits(int m) {
int res = 0;
for (int i = 0; i < maxK; i++) {
res += (m >> i) & 1;
}
return res;
}
long long pow2[maxN + 5];
int main(void) {
int n;
cin >> n;
pow2[0] = 1;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
F[x]++;
pow2[i + 1] = (pow2[i] * 2LL) % MOD;
}
for (int i = maxK - 1; i >= 0; i--) {
for (int mask = (1 << i); mask < maxN; mask++) {
if ((1 << i) & mask) {
F[mask ^ (1 << i)] += F[mask];
}
}
}
long long res = 0;
for (int mask = 0; mask < maxN; mask++) {
if (bits(mask) & 1) {
res = (res - (pow2[F[mask]] - 1) + MOD) % MOD;
} else {
res = (res + (pow2[F[mask]] - 1) + MOD) % MOD;
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
const int MOD = 1e9 + 7;
int dp[maxn];
int Pow2[maxn] = {1};
int main() {
for (int i = 1; i <= 1000000; i++) Pow2[i] = (Pow2[i - 1] << 1) % MOD;
int N;
while (cin >> N) {
memset(dp, 0, sizeof dp);
for (int i = 1; i <= N; i++) {
int t;
scanf("%d", &t);
dp[t]++;
}
for (int k = 0; k < 20; k++) {
for (int i = 0; i <= 1000000; i++) {
if (i & (1 << k)) {
int t = i & (~(1 << k));
dp[t] += dp[i];
}
}
}
long long ans = 0;
for (int i = 0; i <= 1000000; i++) {
int cnt = __builtin_popcount(i);
if (cnt & 1)
ans -= Pow2[dp[i]] - 1;
else
ans += Pow2[dp[i]] - 1;
ans %= MOD;
}
ans = (ans + MOD) % MOD;
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int dp[(1 << 21)][21];
int n;
int arr[1000001];
int power(int x, int y) {
if (y == 0) return 1;
int a = power(x, y / 2);
a = (1LL * a * a) % mod;
if (y % 2) a = (1LL * a * x) % mod;
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 1; i <= n; i++) dp[arr[i]][0]++;
int tot = 0;
for (int k = 1; k <= 20; k++) {
for (int i = 0; i < (1 << 20); i++) {
dp[i][k] = dp[i][k - 1];
if ((i & (1 << (k - 1))) == 0) dp[i][k] += dp[i + (1 << (k - 1))][k - 1];
}
}
for (int i = 0; i <= 1000000; i++) {
if (dp[i][20] == 0) continue;
int val = power(2, dp[i][20]);
val--;
if (val < 0) val += mod;
if (__builtin_popcount(i) % 2) {
tot -= val;
if (tot < 0) tot += mod;
} else {
tot += val;
tot %= mod;
}
}
cout << tot;
}
|
#include <bits/stdc++.h>
const int N = 3e6 + 5;
int bit[N], pw[N], f[N];
char IN[500000], *SS = IN, *TT = IN;
inline int read() {
int now = 0;
register char c =
(SS == TT && (TT = (SS = IN) + fread(IN, 1, 500000, stdin), SS == TT)
? EOF
: *SS++);
for (; !isdigit(c);
c = (SS == TT && (TT = (SS = IN) + fread(IN, 1, 500000, stdin), SS == TT)
? EOF
: *SS++))
;
for (; isdigit(c);
now = now * 10 + c - '0',
c = (SS == TT && (TT = (SS = IN) + fread(IN, 1, 500000, stdin), SS == TT)
? EOF
: *SS++))
;
return now;
}
int main() {
int n = read(), lim = 0;
for (int t, i = 1; i <= n; ++i) ++f[t = read()], lim = std::max(lim, t);
pw[0] = 1;
for (int i = 1; i <= n; ++i)
pw[i] = pw[i - 1] << 1, pw[i] >= 1000000007 && (pw[i] -= 1000000007);
for (int i = 0; 1 << i <= lim; ++i)
for (int s = 0; s <= lim; ++s)
if (!(s >> i & 1))
(f[s] += f[s | (1 << i)]) >= 1000000007 && (f[s] -= 1000000007);
long long ans = 0;
for (int i = 1; i <= lim; ++i) bit[i] = bit[i ^ (i & -i)] ^ 1;
for (int i = 0; i <= lim; ++i)
ans += bit[i] ? 1000000007 - pw[f[i]] + 1 : pw[f[i]] - 1;
printf("%I64d\n", ans % 1000000007);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const int V = (1 << 20) + 10;
const int P = 1000000007;
int Pow(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = (long long)ret * x % P;
x = (long long)x * x % P;
y /= 2;
}
return ret;
}
void utf(int *a, int l, int r) {
if (l + 1 != r) {
int mid = (l + r) / 2;
for (int i = 0; i < mid - l; i++) {
a[l + i] -= a[mid + i];
if (a[l + i] < 0) a[l + i] += P;
}
utf(a, l, mid);
utf(a, mid, r);
}
}
void tf(int *a, int l, int r) {
if (l + 1 != r) {
int mid = (l + r) / 2;
tf(a, l, mid);
tf(a, mid, r);
for (int i = 0; i < mid - l; i++) {
if (((l + i) & (mid + i)) != (l + i))
while (1)
;
a[l + i] += a[mid + i];
if (a[l + i] >= P) a[i + l] -= P;
}
}
}
int cnt[V], q[V];
int n, x, pro[V];
int pt[V];
int main() {
pt[0] = 1;
for (int i = 1; i < (1 << N); i++) pt[i] = pt[i - 1] * 2 % P;
while (~scanf("%d", &n)) {
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n; i++) {
scanf("%d", &x);
cnt[x]++;
}
tf(cnt, 0, (1 << N));
for (int i = 0; i < (1 << N); i++) pro[i] = pt[cnt[i]];
utf(pro, 0, (1 << N));
printf("%d\n", pro[0]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int B = 20, T = (1 << B) + 1, MOD = (int)1e9 + 7;
int n, a[T], c[T], p2[T], dp[2][T];
inline int add(int u, int v) {
u += v;
return (u >= MOD) ? u - MOD : u;
}
void process() {
for (int i = 0; i < T; i++) dp[1][i] = c[i];
for (int i = 0; i < B; i++) {
int s = i & 1;
for (int j = 0; j < T - 1; j++) {
int u = j & (1 << i);
if (u)
dp[s][j] = dp[s ^ 1][j];
else {
dp[s][j] = dp[s ^ 1][j] + dp[s ^ 1][j + (1 << i)];
}
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) ++c[a[i]];
p2[0] = 1;
for (int i = 1; i < T; i++) p2[i] = add(p2[i - 1], p2[i - 1]);
int ans = 1;
process();
for (int i = 0; i < T; i++) {
int pc = __builtin_popcount(i);
if (pc & 1)
ans = add(ans, MOD - p2[dp[1][i]]);
else
ans = add(ans, p2[dp[1][i]]);
}
printf("%d\n", ans);
}
|
#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 = (1 << 20) + 10;
int F[maxn];
int A[maxn], B[maxn];
int pow2[maxn];
int ans[maxn];
int main(void) {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
scanf("%d", &A[i]);
B[A[i]]++;
}
int N = 20;
pow2[0] = 1;
for (int i = 1; i < (1 << N); ++i) pow2[i] = pow2[i - 1] * 2 % mod;
for (int mask = 0; mask < (1 << N); ++mask) F[mask] = B[mask];
for (int i = 0; i < N; ++i) {
for (int mask = (1 << N) - 1; mask >= 0; --mask)
if (mask & (1 << i)) F[mask ^ (1 << i)] += F[mask];
}
int ans = 0;
for (int mask = 0; mask < (1 << N); ++mask) {
int t = 1;
if (__builtin_popcount(mask) & 1) t = -1;
ans += 1ll * t * (pow2[F[mask]]) % mod;
ans = (ans % mod + mod) % mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int L = 20, N = 1e6 + 5;
const long long MOD = 1e9 + 7;
int dp[1 << L], n;
long long pow2[N];
int main() {
scanf("%d", &n);
int a;
for (int i = (int)1; i <= n; i++) {
scanf("%d", &a);
dp[a]++;
}
pow2[0] = 1;
for (int i = (int)1; i <= N - 1; i++) pow2[i] = pow2[i - 1] * 2 % MOD;
for (int i = (int)0; i <= L - 1; i++)
for (int msk = (int)0; msk <= (1 << L) - 1; msk++)
if (msk >> i & 1 ^ 1) dp[msk] += dp[msk ^ (1 << i)];
long long ans = (pow2[dp[0]] - 1 + MOD) % MOD;
for (int msk = (int)1; msk <= (1 << L) - 1; msk++) {
if (dp[msk] == 0) continue;
if (__builtin_popcount(msk) % 2)
ans = (ans - pow2[dp[msk]] + 1 + MOD) % MOD;
else
ans = (ans + pow2[dp[msk]] - 1 + MOD) % MOD;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int bts = 20;
const int limit = 1 << bts;
class Buffer {
public:
Buffer(int _dim) {
dim = _dim;
data.resize(dim + 11);
refill();
}
Buffer& operator>>(int& a) {
while (!is_digit(data[pos]))
if (++pos == dim) refill();
a = 0;
while (is_digit(data[pos])) {
a = a * 10 + data[pos] - '0';
if (++pos == dim) refill();
}
return *this;
}
private:
int dim, pos;
vector<char> data;
bool is_digit(char c) { return '0' <= c && c <= '9'; }
void refill() {
memset(&data[0], 0, dim);
fread(&data[0], 1, dim, stdin);
pos = 0;
}
};
int n, i, x;
long long data[limit];
void add(long long& a, long long b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
void supraset() {
int i, j;
for (i = 0; i < bts; i++)
for (j = 0; j < limit; j++)
if ((j & (1 << i)) == 0) add(data[j], data[j ^ (1 << i)]);
}
long long poww(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) ans = (ans * a) % 1000000007;
b >>= 1;
a = (a * a) % 1000000007;
}
return ans;
}
void inv_supraset() {
int i, j;
for (i = 0; i < bts; i++)
for (j = 0; j < limit; j++)
if ((j & (1 << i)) == 0) add(data[j], 1000000007 - data[j ^ (1 << i)]);
}
int main() {
Buffer fin(1 << 20);
fin >> n;
for (i = 1; i <= n; i++) fin >> x, data[x]++;
supraset();
for (i = 0; i < limit; i++) data[i] = poww(2, data[i]);
inv_supraset();
cout << data[0];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2020;
const int INF = 1000000000;
const long long Mod = 1000000007LL;
const int tot = (1 << 20);
int cnt[tot + 10];
void add(long long &x, long long y) {
x += y;
if (x >= Mod) x -= Mod;
}
long long pow_mod(long long a, long long k) {
long long ret = 1;
while (k) {
if (k & 1) ret = ret * a % Mod;
a = a * a % Mod;
k >>= 1;
}
return ret;
}
int main() {
int n;
scanf("%d", &n);
int cur = tot - 1;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
cnt[x]++;
cur = cur & x;
}
if (cur) {
printf("0\n");
return 0;
}
for (int i = 0; i < 20; i++) {
for (int j = 0; j < tot; j++) {
if (j & (1 << i)) {
cnt[j ^ (1 << i)] += cnt[j];
}
}
}
long long ans = 0;
for (int i = 0; i < tot; i++) {
long long tmp = pow_mod(2LL, cnt[i]);
if (__builtin_popcount(i) & 1) {
ans = (ans - tmp + Mod) % Mod;
} else {
ans = (ans + tmp) % Mod;
}
}
ans = (ans % Mod + Mod) % Mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int L = 20, N = 1e6 + 5;
const long long MOD = 1e9 + 7;
int dp[1 << L], n;
long long pow2[N];
int main() {
scanf("%d", &n);
int a;
for (int i = (int)1; i <= n; i++) {
scanf("%d", &a);
dp[a]++;
}
pow2[0] = 1;
for (int i = (int)1; i <= N - 1; i++) pow2[i] = pow2[i - 1] * 2 % MOD;
for (int i = (int)0; i <= L - 1; i++)
for (int msk = (int)0; msk <= (1 << L) - 1; msk++)
if (msk >> i & 1 ^ 1) dp[msk] += dp[msk ^ (1 << i)];
for (int msk = (int)0; msk <= (1 << L) - 1; msk++) {
}
long long ans = (pow2[dp[0]] - 1 + MOD) % MOD;
for (int msk = (int)1; msk <= (1 << L) - 1; msk++) {
if (dp[msk] == 0) continue;
if (__builtin_popcount(msk) % 2) {
ans = (ans - pow2[dp[msk]] + 1 + MOD) % MOD;
} else {
ans = (ans + pow2[dp[msk]] - 1 + MOD) % MOD;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
int A[2000000];
int F[2000000][25];
int cnt[2000000];
long long Ans = 0;
long long MOD = 1000000007;
long long two(int x) {
if (x == 0) return 1;
long long p = two(x / 2);
if (x % 2)
return p * p * 2 % MOD;
else
return p * p % MOD;
}
int main() {
cin >> N;
for (int Ni = 0; Ni < N; Ni++) {
cin >> A[Ni];
F[A[Ni]][0]++;
}
int n = (1 << 20);
for (int bi = 1, di = 1; bi <= 20; bi++, di *= 2)
for (int i = 0; i <= n; i++) {
if (i & di)
F[i][bi] = F[i][bi - 1], cnt[i]++;
else
F[i][bi] = F[i][bi - 1] + F[i + di][bi - 1];
}
for (int i = 0; i <= n; i++) {
int f = cnt[i] % 2 ? -1 : 1;
long long p = two(F[i][20]);
Ans += f * (p - 1);
Ans %= MOD;
Ans += MOD;
Ans %= MOD;
}
cout << Ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, -1, 0, 1, -1, 0, 1};
int kx8[] = {1, 1, 2, 2, -1, -1, -2, -2};
int ky8[] = {2, -2, 1, -1, 2, -2, 1, -1};
const int M = (1 << 20) + 5;
long long dp[M];
long long relax(long long val) {
if (val >= 1000000007) val -= 1000000007;
if (val >= 1000000007) val %= 1000000007;
if (val < 0) val += 1000000007;
return val;
}
long long pwr[M];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, N, m;
cin >> m;
for (int i = 0; i < (m); i++) {
int a;
cin >> a;
dp[a]++;
}
pwr[0] = 1;
for (int i = 1; i <= m; i++) {
pwr[i] = (pwr[i - 1] * 2LL) % 1000000007;
}
N = 20;
n = (1 << N);
for (int i = 0; i < N; ++i) {
for (int mask = n - 1; mask >= 0; --mask) {
if (!(bool)(mask & (1 << i))) {
dp[mask] += dp[mask ^ (1 << i)];
}
}
}
long long res = 0;
for (long long i = 0; i < n; i++) {
if (__builtin_popcountll(i) % 2) {
res -= pwr[dp[i]];
res = relax(res);
} else {
res += pwr[dp[i]];
res = relax(res);
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20) + 100;
bool one(int mask, int i) { return mask & (1 << i); }
int mod = 1000000007;
int n, a[N], d[N];
int p[N];
int cnt[N];
int was[N];
int main() {
scanf("%d", &n);
p[0] = 1;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
p[i] = p[i - 1] << 1;
if (p[i] >= mod) p[i] -= mod;
d[a[i]]++;
}
for (int i = 0; i <= n; ++i) p[i] = (p[i] - 1 + mod) % mod;
for (int i = 20; i >= 0; --i) {
for (int j = (1 << i); j < (1 << 20); ++j) {
if (one(j, i)) d[j - (1 << i)] += d[j];
}
}
long long ans = 0;
for (int i = 1; i <= 1000000; ++i) {
if (d[i]) {
int kol = __builtin_popcount(i);
if (kol & 1)
ans = (ans + p[d[i]]) % mod;
else
ans = (ans - p[d[i]] + mod) % mod;
}
}
ans = p[n] - ans;
ans %= mod;
ans += mod;
ans %= mod;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
#pragma optimization_level 3
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
using namespace std;
template <class A, class B>
ostream& operator<<(ostream& os, const pair<A, B>& p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
string sep;
for (const auto& x : v) os << sep << x, sep = ", ";
return os << '}';
}
template <class T, class U>
ostream& operator<<(ostream& os, const set<T, U>& v) {
os << "{";
string sep;
for (const auto& x : v) os << sep << x, sep = ", ";
return os << '}';
}
template <class T, class U>
ostream& operator<<(ostream& os, const multiset<T, U>& v) {
os << "{";
string sep;
for (const auto& x : v) os << sep << x, sep = ", ";
return os << '}';
}
template <class T, class... U>
void pr(T&& a, U&&... b) {
cout << forward<T>(a);
(int[]){(cout << " " << forward<U>(b), 0)...};
cout << "\n";
}
template <class T, class... U>
void re(T&& a, U&&... b) {
cin >> forward<T>(a);
(int[]){(cin >> forward<U>(b), 0)...};
}
template <class T>
inline bool ckmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
inline bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
using PR_queue = priority_queue<T, vector<T>, greater<T>>;
pair<int, int> DR8[] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1},
{-1, 1}, {-1, -1}, {1, 1}, {1, -1}};
pair<int, int> DR4[] = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};
const long long mod = 1e9 + 7;
long long gcd(long long a, long long b) {
if (b > a) swap(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
void extgcd(long long a, long long b, long long& x, long long& y) {
if (a == 0) {
x = a;
y = b;
return;
}
extgcd(b % a, a, x, y);
long long y1 = y, x1 = x;
x = y1 - (b / a) * x1;
y = x1;
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long bexp(long long num, long long e) {
long long ans = 1;
while (e > 0) {
if (e & 1) {
ans *= num;
}
num *= num;
e >>= 1;
}
return ans;
}
long long mexp(long long num, long long e) {
long long ans = 1;
while (e > 0) {
if (e & 1) {
ans = (ans * num) % mod;
}
num = (num * num) % mod;
e >>= 1;
}
return ans % mod;
}
long long modinv(long long a) { return mexp(a, mod - 2); }
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < (n); i++) {
cin >> a[i];
};
int MAXN = (1 << 20);
vector<long long> dp(MAXN, 0);
for (int i = 0; i < (n); i++) {
dp[a[i]]++;
}
for (int i = 0; i < (20); i++) {
for (int mask = 0; mask < (MAXN); mask++) {
if (!(mask & (1LL << (i)))) dp[mask] += dp[mask | (1 << i)];
}
}
long long ans = 0;
for (int i = 0; i < (MAXN); i++) {
int sgn = (__builtin_popcount(i) % 2) ? -1 : 1;
ans = (((ans + sgn * mexp(2, dp[i])) % mod) + mod) % mod;
}
pr(ans);
}
int main() {
cin.tie(0)->sync_with_stdio(0);
if (fopen("test"
".in",
"r"))
freopen(
"test"
".in",
"r", stdin),
freopen(
"test"
".out",
"w", stdout);
;
int t = 1;
for (int T = 1; T <= (t); T++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long sum = 0, ff = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') ff = -1;
ch = getchar();
}
while (isdigit(ch)) sum = sum * 10 + (ch ^ 48), ch = getchar();
return sum * ff;
}
const long long N = 1e6 + 5;
const long long mo = 1e9 + 7;
long long n, m, ans, f[22], dp[N], g[N];
inline void Add(long long &x, long long y) {
x += y;
if (x >= mo) x -= mo;
}
signed main() {
for (long long i = 1; g[0] = 1, i <= 1e6; i++) g[i] = (g[i - 1] << 1) % mo;
n = read();
for (long long i = 1; i <= n; i++) dp[read()]++;
for (long long j = 0; j <= 21; j++)
for (long long i = 1; i <= 1e6; i++)
if ((1ll << j) & i) Add(dp[i ^ (1ll << j)], dp[i]);
for (long long i = 0; i <= 1e6; i++) {
long long gs = 0;
for (long long j = 0; j <= 21; j++)
if ((1ll << j) & i) gs++;
Add(f[gs], g[dp[i]] - 1);
}
for (long long i = 0; i <= 21; i++)
(i & 1) ? Add(ans, -f[i]) : Add(ans, f[i]);
printf("%lld\n", (ans + mo) % mo);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n, bit;
cin >> n;
vector<int> a(n);
vector<long long> p(n + 1);
p[0] = 1;
int mx = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
mx = max(mx, a[i]);
p[i + 1] = p[i] * 2 % mod;
}
bit = log2(mx) + 1;
vector<int> f(1 << bit);
for (auto x : a) {
f[x]++;
}
for (int i = 0; i < bit; i++) {
for (int mask = 0; mask < 1 << bit; mask++) {
if (mask >> i & 1) {
f[mask ^ (1 << i)] += f[mask];
}
}
}
long long ans = p[n] - 1;
for (int i = 1; i <= mx; i++) {
if (__builtin_popcount(i) & 1) {
ans = (ans - p[f[i]] + 1) % mod;
} else {
ans = (ans + p[f[i]] - 1) % mod;
}
}
cout << (ans + mod) % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const double eps = 1e-8;
const int nm = 1100005;
int n, k, m, t;
long long res;
int cnt[nm], f[nm][23];
int POW(int x, int z) {
if (z == 0) return 1;
if (z == 1) return x % MOD;
int u = POW(x, z >> 1);
u = ((long long)u * u) % MOD;
if (z % 2) u = ((long long)u * x) % MOD;
return u;
}
int main() {
int i, j, x, y, z, w;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &x);
cnt[x]++;
}
for (i = (1 << 20) - 1; i >= 0; i--) {
if (i & 1)
f[i][0] = cnt[i];
else
f[i][0] = cnt[i] + cnt[i + 1];
for (j = 1; j < 20; j++) {
if (i & (1 << j))
f[i][j] = f[i][j - 1];
else
f[i][j] = f[i][j - 1] + f[i + (1 << j)][j - 1];
}
}
for (i = (1 << 20) - 1; i >= 0; i--) {
x = __builtin_popcount(i);
if (x & 1)
res -= POW(2, f[i][19]);
else
res += POW(2, f[i][19]);
res = (res + MOD) % MOD;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
int dp[(1 << 20) - 1];
int g[(1 << 20) - 1];
long long int modPow(int a, int n) {
if (n == 0) return 1;
if (n % 2 == 0)
return (modPow(a, n / 2) * modPow(a, n / 2)) % mod;
else
return (modPow(a, n / 2) * modPow(a, n / 2) * a) % mod;
;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
dp[x]++;
}
for (int i = 0; i < 20; i++) {
for (int mask = (1 << 20) - 2; mask >= 0; mask--) {
if (mask & (1 << i)) {
dp[mask ^ (1 << i)] += dp[mask];
}
}
}
for (int i = 0; i < (1 << 20) - 1; i++) {
g[i] = __builtin_popcount(i);
}
long long int ans = 0;
for (int i = 0; i < (1 << 20) - 1; i++) {
ans += (long long int)pow(-1, g[i]) * (modPow(2, dp[i]) - 1);
ans = (ans + mod) % mod;
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int mod = 1e9 + 7;
int n;
int cnt[1 << 22], two[N];
template <typename T>
inline void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
inline void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
inline void read(T &x) {
T f = 1;
x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
x *= f;
}
inline void inc(int &x, int y) { x = x + y < mod ? x + y : x + y - mod; }
inline void dec(int &x, int y) { x = x - y >= 0 ? x - y : x - y + mod; }
int main() {
read(n);
for (int i = 1; i <= n; ++i) {
int x;
read(x);
++cnt[x];
}
two[0] = 1;
for (int i = 1; i <= n; ++i) two[i] = 2ll * two[i - 1] % mod;
for (int i = 0; i <= 20; ++i)
for (int s = 0; s < (1 << 20); ++s)
if (s >> i & 1) cnt[s ^ (1 << i)] += cnt[s];
int ans = 0;
for (int s = 0; s < (1 << 20); ++s)
if (__builtin_popcount(s) & 1)
dec(ans, (two[cnt[s]] - 1 + mod) % mod);
else
inc(ans, (two[cnt[s]] - 1 + mod) % mod);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int two[(1 << 20)];
int A[(1 << 20)];
int S[(1 << 20)];
int main() {
two[0] = 1;
for (int i = (1); i <= ((1 << 20) - 1); ++i)
two[i] = two[i - 1] * 2 % 1000000007;
int N;
scanf("%d", &N);
for (int i = (0); i < (N); ++i) scanf("%d", A + i), S[A[i]]++;
for (int b = (0); b < (20); ++b)
for (int s = (0); s < ((1 << 20)); ++s)
if (s & (1 << b)) S[s - (1 << b)] += S[s];
int ans = 0;
for (int s = (0); s < ((1 << 20)); ++s)
if (__builtin_popcount(s) & 1)
ans = (ans - two[S[s]] + 1000000007) % 1000000007;
else
ans = (ans + two[S[s]]) % 1000000007;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
template <class T>
void read(T &x) {
x = 0;
int c = getchar();
int flag = 0;
while (c < '0' || c > '9') flag |= (c == '-'), c = getchar();
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (flag) x = -x;
}
template <class T>
T _max(T a, T b) {
return b < a ? a : b;
}
template <class T>
T _min(T a, T b) {
return a < b ? a : b;
}
template <class T>
bool checkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
bool checkmin(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
const int mod = 1000000000 + 7;
void add(int &a, int b) {
a += b;
(a >= mod) && (a -= mod);
}
void sub(int &a, int b) {
a -= b;
(a < 0) && (a += mod);
}
void mul(int &a, int b) { a = (long long)a * b % mod; }
int Add(int a, int b) {
a += b;
return a >= mod ? a - mod : a;
}
int Sub(int a, int b) {
a -= b;
return a < 0 ? a + mod : a;
}
int Mul(int a, int b) { return (long long)a * b % mod; }
int qpow(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = (long long)ans * a % mod;
a = (long long)a * a % mod;
b >>= 1;
}
return ans;
}
int Inv(int a) { return qpow(a, mod - 2); }
const int N = 1000005;
int n;
int a[N], pw2[N];
int b[1 << 20];
void init() {
read(n);
pw2[0] = 1;
for (int i = 1; i <= n; ++i) {
pw2[i] = Add(pw2[i - 1], pw2[i - 1]);
read(a[i]);
++b[a[i]];
}
for (int i = 0; i < 20; ++i) {
for (int S = (1 << 20) - 1; S >= 0; --S)
if (!(S >> i & 1)) {
add(b[S], b[S | (1 << i)]);
}
}
for (int i = 0; i < (1 << 20); ++i) {
b[i] = pw2[b[i]];
}
}
void solve() {
for (int i = 0; i < 20; ++i) {
for (int S = (1 << 20) - 1; S >= 0; --S)
if (!(S >> i & 1)) {
sub(b[S], b[S | (1 << i)]);
}
}
printf("%d\n", b[0]);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e6 + 10;
const long long p = 1e9 + 7;
long long n, a[N], f[N], ans;
long long get(long long x) {
long long sum = 0;
while (x) x -= (x & -x), sum++;
return sum;
}
long long POW(long long a, long long b) {
if (!b) return 1;
if (b == 1) return a;
long long sum = POW(a, b / 2);
if (b % 2) return sum * sum % p * a % p;
return sum * sum % p;
}
signed main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]), f[a[i]]++;
for (long long j = 0; j < 20; j++)
for (long long i = (1 << 20) - 1; i >= 0; i--)
if ((i & (1 << j)) == 0) f[i] += f[i + (1 << j)];
for (long long i = 0; i < (1 << 20); i++)
ans += (get(i) % 2 ? -1 : 1) * (POW(2, f[i]) - 1 + p) % p, ans += p,
ans %= p;
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1048576 + 50;
const int mod = 1e9 + 7;
int n, f[MAXN], pw[MAXN];
void fwt(int *a, int len, int flg) {
for (int i = 2; i <= len; i <<= 1)
for (int j = 0; j < len; j += i)
for (int k = j; k < j + i / 2; ++k)
a[k] = (a[k] + 1ll * (flg == 1 ? 1 : mod - 1) * a[k + i / 2]) % mod;
}
int main() {
scanf("%d", &n);
int len = pw[0] = 1;
for (int i = 1, x; i <= n; ++i) {
scanf("%d", &x), ++f[x];
while (len <= x) len <<= 1;
pw[i] = pw[i - 1] * 2ll % mod;
}
fwt(f, len, 1);
for (int i = 0; i < len; ++i) f[i] = pw[f[i]];
fwt(f, len, -1);
printf("%d\n", f[0] == pw[n] ? f[0] - 1 : f[0]);
}
|
#include <bits/stdc++.h>
const double eps = 0.000000001;
using namespace std;
const int mx_n = 1024 * 1024;
int a[mx_n];
int F[mx_n];
int two[mx_n];
void solve() {
int N = 20;
int n;
cin >> n;
fill(F, F + mx_n, 0);
fill(a, a + mx_n, 0);
vector<int> b;
int x;
for (int i = 0; i < n; i++) {
cin >> x;
a[((1 << N) - 1) ^ x]++;
}
two[0] = 1;
for (int i = 1; i < mx_n; i++) {
two[i] = two[i - 1] * 2;
if (two[i] > 1000000007) two[i] -= 1000000007;
}
for (int i = 0; i < (1 << N); ++i) F[i] = a[i];
for (int i = 0; i < N; ++i)
for (int mask = 0; mask < (1 << N); ++mask) {
if (mask & (1 << i)) F[mask] += F[mask ^ (1 << i)];
}
long long ans = 0;
for (int i = 0; i < (1 << N); i++) {
int tmp = two[F[((1 << N) - 1) ^ i]];
int u = __builtin_popcount(i);
if (u % 2 == 1) tmp *= -1;
ans = (tmp + ans) % 1000000007;
}
ans = (ans + 1000000007) % 1000000007;
printf("%lld", ans);
}
int main(int argc, char const *argv[]) {
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1 << 20, mod = 1e9 + 7;
long long dp[2][N];
long long modexp(long long a, long long n) {
if (n == 0) return 1;
if (n == 1) return a;
long long x = modexp(a, n / 2);
x = (x * x) % mod;
if (n & 1) x = (x * a) % mod;
return x;
}
int32_t main() {
ios ::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
long long p;
cin >> p;
dp[1][p]++;
}
for (long long i = 19; i >= 0; i--) {
long long cur = i & 1;
for (long long mask = 0; mask < N; mask++) {
dp[cur ^ 1][mask] = dp[cur][mask];
if (mask & (1 << i)) {
dp[cur ^ 1][mask ^ (1 << i)] += dp[cur][mask];
}
}
}
long long ans = 0;
for (long long i = 0; i < N; i++) {
if (__builtin_popcount(i) % 2) {
ans -= modexp(2, dp[1][i]) - 1;
} else {
ans += modexp(2, dp[1][i]) - 1;
}
ans = (ans + mod) % mod;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 20, MOD = 1e9 + 7;
int p[1 << MAXN], dp[1 << MAXN];
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
dp[x]++;
}
for (int i = 0; i < MAXN; i++)
for (int mask = 0; mask < (1 << MAXN); mask++)
dp[mask] += (mask >> i & 1 ? 0 : dp[mask ^ (1 << i)]);
p[0] = 1;
for (int i = 1; i < (1 << MAXN); i++) p[i] = (p[i - 1] * 2) % MOD;
int ans = 0;
for (int mask = 0; mask < (1 << MAXN); mask++) {
int cur = p[dp[mask]];
if (__builtin_popcount(mask) & 1)
ans -= cur;
else
ans += cur;
ans %= MOD;
}
ans = (ans + MOD) % MOD;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int n, m, x;
long long ans, f[2000001], g[2000001];
inline long long read() {
long long x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x;
}
long long qpow(long long x, long long y) {
long long sum = 1;
while (y) {
if (y & 1) sum = sum * x % mod;
x = x * x % mod;
y >>= 1;
}
return sum;
}
void FWT_And(int n, int jdg, long long *f) {
for (long long i = 2, j = 1; i <= n; i <<= 1, j <<= 1)
for (long long k = 0; k < n; k += i)
for (long long l = 0; l < j; l++)
f[k + l] = (f[k + l] + f[j + k + l] * jdg % mod + mod) % mod;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
x = read();
f[x]++;
m = max(m, x);
}
n = 1;
while (n <= m) n <<= 1;
FWT_And(n, 1, f);
g[0] = 1;
for (int i = 0; i < n; i++) {
if (!g[i]) g[i] = -g[i ^ (i & (-i))];
ans = (ans + g[i] * (qpow(2, f[i]) - 1) % mod + mod) % mod;
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
template <typename Tp>
Tp Max(const Tp &a, const Tp &b) {
return a > b ? a : b;
}
template <typename Tp>
Tp Min(const Tp &a, const Tp &b) {
return a < b ? a : b;
}
template <typename Tp>
void Read(Tp &x) {
Tp in = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
in = in * 10 + ch - '0';
ch = getchar();
}
x = in * f;
}
const int SN = 2000000 + 10;
const int MOD = 1000000007;
int f[SN], a[SN], n;
int power[SN];
int main() {
power[0] = 1;
for (int i = 1; i <= SN - 10; i++) power[i] = (power[i - 1] * 2) % MOD;
while (scanf("%d", &n) != EOF) {
memset(f, 0, sizeof f);
for (int i = 1; i <= n; i++) Read(a[i]), f[a[i]]++;
for (int i = 1; i <= 20; i++)
for (int sta = SN - 10; sta >= 0; sta--) {
if ((sta >> (i - 1)) & 1) f[sta ^ (1 << (i - 1))] += f[sta];
}
long long ans = (power[n] - 1 + MOD) % MOD;
for (int sta = 1; sta <= SN - 10; sta++) {
int cnt = 0;
for (int i = 1; i <= 20; i++)
if ((sta >> (i - 1)) & 1) cnt++;
if (cnt & 1)
ans = (ans - (power[f[sta]] - 1 + MOD) % MOD + MOD) % MOD;
else
ans = (ans + (power[f[sta]] - 1) + MOD) % MOD;
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& out, vector<T> const& a) {
out << "[";
for (int i = 0; i < int((a).size()); ++i) {
if (i != 0) {
out << ", ";
}
out << a[i];
}
out << "]";
return out;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> const& p) {
out << "(" << p.first << ", " << p.second << ")";
return out;
}
const int N = 1e6;
struct Data {
int n;
int a[N];
bool read() {
if (scanf("%d", &n) != 1) {
return false;
}
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
return true;
}
long long ans;
void write() { printf("%d\n", (int)ans); }
virtual void solve() {}
virtual void clear() { *this = Data(); }
void gen() {
n = 1e6;
for (int i = 0; i < n; ++i) {
a[i] = i;
}
}
};
const int mod = 1e9 + 7;
int sum(int x, int y) {
x += y;
if (x >= mod) {
x -= mod;
}
return x;
}
const int L = 20;
const int C = 1 << L;
int cnt[C + 1], cnt2[C + 1];
int pw2[N + 1];
struct Solution : Data {
void solve() {
int mx = 0;
for (int i = 0; i < n; ++i) {
++cnt[a[i]];
}
for (int i = 0; i < L; ++i) {
for (int j = 0; j < C; ++j) {
if (j & (1 << i)) {
cnt[j ^ (1 << i)] += cnt[j];
}
}
}
pw2[0] = 1;
for (int i = 1; i <= n; ++i) {
pw2[i] = sum(pw2[i - 1], pw2[i - 1]);
}
ans = 0;
for (int i = 1; i < C; ++i) {
long long e = -1;
for (int j = 0; j < L; ++j) {
if (i & (1 << j)) {
e *= -1;
}
}
ans += e * (pw2[cnt[i]] - 1);
ans %= mod;
ans += mod;
ans %= mod;
};
ans = (pw2[n] - 1 - ans) % mod;
ans += mod;
ans %= mod;
}
Solution() {}
Solution(Data d) : Data(d) {}
void clear() {
*this = Solution();
memset(cnt, 0, sizeof(cnt));
memset(cnt2, 0, sizeof(cnt2));
}
};
Solution sol;
void test() {
const int C = 1e6;
long long cnt = 0;
for (int i = 0; i <= C; ++i) {
for (int j = i; j > 0; j = (j - 1) & i) {
++cnt;
}
};
}
int main() {
sol.read();
sol.solve();
sol.write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000007;
int cnt[1024 * 1024 + 10][21];
int one[1024 * 1024 + 10];
void init() {
vector<int> vt;
for (int i = 1000000; i > 0; --i) {
for (int j = 2; j < 21; ++j) cnt[i][j] /= j;
vt.clear();
for (int j = 0; j < 20; ++j)
if (i & (1 << j)) one[i]++, vt.push_back(1 << j);
for (int j = 0; j < 20; ++j)
if (cnt[i][j])
for (int k = 0; k < vt.size(); ++k) cnt[i ^ vt[k]][j + 1] += cnt[i][j];
}
}
int prm[1024 * 1024 + 10];
int main() {
prm[0] = 1;
for (int i = 1; i < 1000010; ++i) prm[i] = prm[i - 1] * 2 % inf;
int n, x;
scanf("%d", &n);
long long res = prm[n] - 1;
while (n--) {
scanf("%d", &x);
cnt[x][0]++;
}
init();
for (int i = 1; i <= 1000000; ++i) {
int tmp = cnt[i][0];
for (int j = 1; j <= 20; ++j) tmp += cnt[i][j];
if (one[i] & 1)
res = res - prm[tmp] + 1;
else
res = res + prm[tmp] - 1;
if (res < 0)
res += inf;
else if (res >= inf)
res -= inf;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
constexpr int MAX = 1 << 20;
constexpr int MOD = 1e9 + 7;
int count_bits(int n) {
int result = 0;
while (n) {
result += (n % 2);
n >>= 1;
}
return result;
}
int pow2(int deg) {
if (deg == 0) {
return 1;
}
int result = pow2(deg >> 1);
result = (1ll * result * result) % MOD;
return (deg % 2) ? (2 * result) % MOD : result;
}
int count_zero_groups(const std::vector<int>& vector) {
std::vector<int> dp(MAX);
for (auto x : vector) {
dp[x] += 1;
}
for (int i = 1; i < MAX; i <<= 1) {
for (int j = 0; j < dp.size(); ++j) {
if ((j & i) == 0) {
dp[j] += dp[j + i];
}
}
}
int result = (pow2(vector.size()) + MOD - 1) % MOD;
for (int i = 1; i < MAX; ++i) {
const auto p = (pow2(dp[i]) + MOD - 1) % MOD;
result += (count_bits(i) % 2) ? (MOD - p) : p;
result = result % MOD;
}
return result;
}
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
int size;
std::cin >> size;
std::vector<int> vector(size);
for (auto& x : vector) {
std::cin >> x;
}
std::cout << count_zero_groups(vector) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline long long gcd(long long a, long long b) {
return b == 0 ? a : gcd(b, a % b);
}
inline long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
int dx[] = {0, 0, +1, -1, +1, +1, -1, -1};
int dy[] = {+1, -1, 0, 0, +1, -1, +1, -1};
inline void normal(long long &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, 1000000007 - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
template <typename first, typename second>
ostream &operator<<(ostream &os, const pair<first, second> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream &operator<<(ostream &os, const map<first, second> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
void faltu() { cerr << '\n'; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << '\n';
}
template <typename T, typename... hello>
void faltu(T arg, const hello &...rest) {
cerr << arg << ' ';
faltu(rest...);
}
const int k = 20;
const int mx = 1e6 + 123;
long long dp[1 << k];
int a[mx];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, z = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
dp[a[i]] += (a[i] != 0);
}
for (int i = 0; i < k; i++) {
for (int mask = 1; mask < (1 << k); mask++) {
if ((mask & (1 << i)) == 0) dp[mask] += dp[mask ^ (1 << i)];
}
}
long long ans = modSub(modPow(2, n), 1);
for (int mask = 1; mask < (1 << k); mask++) {
int cnt = 0;
for (int i = 0; i < k; i++) cnt += ((mask & (1 << i)) > 0);
ans = modAdd(ans, modMul(modPow(-1, cnt), modSub(modPow(2, dp[mask]), 1)));
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
extern inline char gc() {
static char RR[23456], *S = RR + 23333, *T = RR + 23333;
if (S == T) fread(RR, 1, 23333, stdin), S = RR;
return *S++;
}
inline int read() {
int p = 0, w = 1;
char c = gc();
while (c > '9' || c < '0') {
if (c == '-') w = -1;
c = gc();
}
while (c >= '0' && c <= '9') p = p * 10 + c - '0', c = gc();
return p * w;
}
int n;
int f[2105000], bit[2105000], ans;
int main() {
n = read();
for (register int i = 1; i <= n; i++) f[read()]++;
bit[0] = 1;
for (register int i = 1; i <= 1000000; i++)
bit[i] = 1ll * 2 * bit[i - 1] % 1000000007;
for (register int i = 0; i <= 19; i++)
for (register int j = 0; j <= 1000000; j++)
if (!(j & bit[i])) f[j] += f[j ^ bit[i]];
for (register int i = 0; i <= 1000000; i++) {
int cnt = 1;
for (register int j = 0; j <= 19; j++)
if (i & bit[j]) cnt = -cnt;
int tmp = cnt * (bit[f[i]] - 1) % 1000000007;
ans = ((ans + tmp) % 1000000007 + 1000000007) % 1000000007;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n;
long long int first[(1LL << 20) + 2];
long long int expo(long long int base, long long int exponent,
long long int mod) {
long long int ans = 1;
while (exponent != 0) {
if ((exponent & 1) == 1) {
ans = ans * base;
ans = ans % mod;
}
base = base * base;
base %= mod;
exponent >>= 1;
}
return ans % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int i, j;
cin >> n;
memset(first, 0, sizeof first);
for (i = 0; i < n; i++) {
long long int x;
cin >> x;
first[x]++;
}
for (long long int i = 0; i < 20; ++i) {
for (long long int mask = 0; mask < (1LL << 20); ++mask) {
if (!(mask & (1LL << i))) {
first[mask] += first[mask | (1LL << i)];
}
}
}
long long int ans = 0;
for (i = 0; i < (1LL << 20); i++) {
long long int setbits = (long long int)(__builtin_popcount(i));
if (setbits % 2)
ans = (ans - expo(2LL, first[i], 1000000007) + 1000000007) % 1000000007;
else
ans = (ans + expo(2LL, first[i], 1000000007)) % 1000000007;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
const int M = 1e6 + 1;
int mod = 1e9 + 7;
int m[N][M], B[M], C[N];
int main() {
int n;
int a;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a), m[0][a]++;
B[0] = 1;
for (int i = 1; i <= n; i++) B[i] = 1ll * 2 * B[i - 1] % mod;
for (int i = 0; i <= n; i++) B[i] = (mod + B[i] - 1) % mod;
for (int i = M - 1; i > -1; i--) {
int cur = 0;
for (int j = 1; j < N; j++) m[j][i] /= j, cur += m[j][i];
for (int k = 0; k < N; k++) {
if (((i >> k) & 1))
for (int j = 0; j < N - 1; j++) m[j + 1][i - (1 << k)] += m[j][i];
}
m[0][i] += cur;
}
int ans = 0;
for (int i = 0; i < M; i++) {
int cur = m[0][i];
if (__builtin_popcount(i) % 2 == 1)
ans = (ans + mod - B[cur]) % mod;
else
ans = (ans + B[cur]) % mod;
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int lim = 1e6;
const int mod = 1e9 + 7;
long long dp[(1 << 20) + 1], a[N];
long long binpow(long long u, long long p) {
if (p == 0) return 1;
if (p == 1) return u;
long long t = binpow(u, p / 2);
if (p & 1)
return t * t % mod * u % mod;
else
return t * t % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
if (fopen("A.inp", "r")) {
freopen("test.inp", "r", stdin);
freopen("test.ans", "w", stdout);
}
long long n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], dp[a[i]]++;
for (int i = 19; i >= 0; --i) {
for (int j = lim; j >= 0; j--) {
if (j & (1 << i)) {
dp[j ^ (1 << i)] += dp[j];
}
}
}
long long ans = 0;
for (int i = 0; i <= lim; i++) {
long long x = __builtin_popcount(i);
if (x & 1) {
ans = (ans - binpow(2ll, dp[i]) + 1 + mod) % mod;
} else {
ans = (ans + binpow(2ll, dp[i]) - 1 + mod) % mod;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = (1 << 20);
const long long MOD = 1e9 + 7;
int dp[M];
long long p2[M], ans;
int32_t main() {
int n;
scanf("%d", &n);
p2[0] = 1;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
dp[x]++;
p2[i + 1] = (p2[i] * 2ll) % MOD;
}
for (int i = 20; ~i; i--)
for (int mask = M; --mask;)
if (mask & (1 << i)) dp[mask ^ (1 << i)] += dp[mask];
for (int i = 0; i < M; i++)
ans += p2[dp[i]] * ((int)__builtin_popcount(i) & 1 ? -1 : 1) + MOD,
ans %= MOD;
return cout << ans << endl, 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.