text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a[500], i, j, l, t, ans, temp;
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
ans = a[0];
for (i = 0; i < n; i++) {
for (j = i; j < n; j++) {
vector<int> m;
vector<int> M;
temp = 0;
for (l = 0; l < i; l++) M.push_back(a[l]);
for (l = i; l <= j; l++) m.push_back(a[l]), temp += a[l];
for (l = j + 1; l < n; l++) M.push_back(a[l]);
sort(m.begin(), m.end());
sort(M.begin(), M.end(), greater<int>());
t = min(m.size(), M.size());
t = min(t, k);
for (l = 0; l < t; l++) {
if (m[l] < M[l])
temp = temp - m[l] + M[l];
else
break;
}
if (temp > ans) ans = temp;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200];
int n, k;
struct cmp {
bool operator()(int &a, int &b) { return a > b; }
};
int cal(int l, int r) {
priority_queue<int, vector<int>, cmp> pq;
int sum = 0;
for (int i = l; i <= r; i++) {
sum += a[i];
pq.push(a[i]);
}
int count = k;
int vis[200] = {0};
while (count--) {
int max_val = INT_MIN, max_pos;
for (int i = 0; i < n; i++) {
if ((i >= l && i <= r) || vis[i]) continue;
if (a[i] > max_val) {
max_val = a[i];
max_pos = i;
}
}
if (max_val > pq.top()) {
vis[max_pos] = 1;
sum = sum - pq.top() + max_val;
pq.pop();
pq.push(max_val);
}
}
return sum;
}
int main() {
while (cin >> n >> k) {
int max_v = INT_MIN;
int c = 0;
while (c < n) cin >> a[c++];
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
max_v = max(max_v, cal(i, j));
}
cout << max_v << endl;
}
}
|
#include <bits/stdc++.h>
typedef struct {
int id;
int value;
} Node_t;
Node_t A[200];
int cmp1(const void *a, const void *b) {
return (*(Node_t *)b).value - (*(Node_t *)a).value;
}
int cmp2(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int main() {
int N, K, i, j, k, Max = -10000;
int Data[200], Cur[200];
scanf("%d %d", &N, &K);
for (i = 0; i < N; ++i) {
scanf("%d", &Data[i]);
A[i].id = i;
A[i].value = Data[i];
}
qsort(A, N, sizeof(Node_t), cmp1);
for (i = 0; i < N; ++i) {
for (j = i; j < N; ++j) {
int sum = 0;
for (k = i; k <= j; ++k) {
Cur[k - i] = Data[k];
sum += Data[k];
}
qsort(Cur, j - i + 1, sizeof(int), cmp2);
int cnt = 0;
int ii = 0;
int jj = 0;
while (1) {
while (A[jj].id >= i && A[jj].id <= j && jj < N) {
++jj;
}
if (jj == N) {
break;
}
while (Cur[ii] >= A[jj].value && ii < j - i + 1) {
++ii;
}
if (ii == j - i + 1) {
break;
}
sum -= Cur[ii];
Cur[ii] = A[jj].value;
sum += Cur[ii];
++ii;
++jj;
if (++cnt == K) {
break;
}
}
if (sum > Max) {
Max = sum;
}
}
}
printf("%d\n", Max);
return 0;
}
|
#include <bits/stdc++.h>
long long memo[(1 << 21)];
long long modexp(long long a, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = ((res % 1000000007) * (a % 1000000007)) % 1000000007;
a = ((a % 1000000007) * (a % 1000000007)) % 1000000007;
n >>= 1;
}
return res;
}
int main(void) {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
int n;
std::cin >> n;
for (int i = 0; i < n; i++) {
int t;
std::cin >> t;
memo[t]++;
}
for (int p = 0; p < 21; p++) {
for (int mask = ((1 << 21) - 1); mask >= 0; mask--) {
if (!(mask & (1 << p))) memo[mask] += memo[mask ^ (1 << p)];
}
}
long long ans = 0;
for (int mask = 0; mask < (1 << 21); mask++) {
int z = __builtin_popcount(mask);
if (z & 1)
ans = ((ans % 1000000007) - (modexp(2, memo[mask]) % 1000000007) +
1000000007) %
1000000007;
else
ans = ((ans % 1000000007) + (modexp(2, memo[mask]) % 1000000007)) %
1000000007;
}
std::cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5;
const int mod = 1e9 + 7;
int n, a[N], pw[N];
long long ans;
int main() {
pw[0] = 1;
for (int i = 1; i < N; i++) {
pw[i] = (pw[i - 1] * 2ll) % mod;
}
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
a[x]++;
}
for (int j = 0; j < 20; j++) {
for (int i = (1 << 20) - 1; i >= 0; i--) {
if (i & (1 << j)) {
a[i - (1 << j)] += a[i];
}
}
}
for (int i = 0; i < pw[20]; i++) {
int bit = __builtin_popcount(i);
if (bit & 1)
ans -= pw[a[i]], ans = (ans + mod) % mod;
else
ans += pw[a[i]], ans = (ans + mod) % mod;
}
cout << ans << endl;
}
|
#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]]++;
}
for (int i = 0; i < k; i++) {
for (int mask = 0; mask < (1 << k); mask++) {
if ((mask & (1 << i)) == 0) dp[mask] += dp[mask ^ (1 << i)];
}
}
long long ans = 0;
for (int mask = 0; 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;
int Set(int N, int pos) { return N = N | (1 << pos); }
int reset(int N, int pos) { return N = N & ~(1 << pos); }
bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
long long po[1000000 + 5];
int dp[1000000 + 3][21], cnt[1000000 + 3];
int dp_func(int mask, int pos) {
if (mask > 1000000) return 0;
if (pos == -1) return cnt[mask];
if (dp[mask][pos] != -1) return dp[mask][pos];
int ret = 0;
if (check(mask, pos) == 0) ret += dp_func(Set(mask, pos), pos - 1);
ret += dp_func(mask, pos - 1);
return dp[mask][pos] = ret;
}
int main() {
int i, j, k, l, m, n;
po[0] = 1;
for (int i = 1; i <= 1000000; i++) {
po[i] = po[i - 1] * 2;
po[i] %= 1000000007;
}
memset(dp, -1, sizeof dp);
scanf("%d", &n);
int ma = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &l);
cnt[l]++;
ma = max(ma, l);
}
long long ans = 0;
for (int i = 0; i <= ma; i++) {
int l = dp_func(i, 19);
if (l == 0) continue;
long long d = po[l] - 1;
if (d < 0) d = (d + 1000000007) % 1000000007;
if (__builtin_popcount(i) & 1)
ans -= d;
else
ans += d;
if (ans < 0) ans = (ans + 1000000007) % 1000000007;
ans = ans % 1000000007;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005000;
const int BASE = 1000000007;
int n, pw[N], f[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
f[x]++;
}
pw[0] = 1;
for (int i = 1; i < N; i++) {
pw[i] = pw[i - 1] + pw[i - 1];
if (pw[i] >= BASE) {
pw[i] -= BASE;
}
}
for (int j = 0; j < 20; j++) {
for (int i = N - 1; i >= 0; i--) {
if (((i & (1 << j)) == 0) && (i + (1 << j) < N)) {
f[i] += f[i + (1 << j)];
}
}
}
for (int i = 0; i < N; i++) {
f[i] = pw[f[i]];
}
int ans = 0;
for (int i = 0; i < N; i++) {
int o = 0;
int x = i;
while (x > 0) {
o ^= 1;
x &= (x - 1);
}
if (o) {
ans -= f[i];
if (ans < 0) {
ans += BASE;
}
} else {
ans += f[i];
if (ans >= BASE) {
ans -= BASE;
}
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20) + 10;
const int MOD = 1000000007;
int f[N];
int p[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
f[a]++;
}
for (int i = 0; i < 20; i++)
for (int j = 0; j < (1 << 20); j++) {
if (j & (1 << i)) {
f[j ^ (1 << i)] += f[j];
}
}
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++) {
f[i] = p[f[i]];
}
for (int i = 0; i < 20; i++) {
for (int j = 0; j < (1 << 20); j++) {
if (j & (1 << i)) {
(f[j ^ (1 << i)] += MOD - f[j]) %= MOD;
}
}
}
printf("%d\n", f[0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T min3(T a, T b, T c) {
return min(a, min(b, c));
};
template <class T>
T max3(T a, T b, T c) {
return max(a, max(b, c));
};
void openFile() {
freopen("/home/khaihanhdk/MyWorkplace/cpp file/a.inp", "r", stdin);
}
const int m = 20;
const int kk = (1 << 20) - 1;
const long long e9 = 1e9 + 7;
void computeS(long long* f) {
for (int i = 0; i < m; i++)
for (int j = 0; j < (1 << m); j++)
if ((j >> i) & 1) f[j] += f[j ^ (1 << i)];
}
int powm(int k) {
if (k % 2 == m % 2) return 1;
return -1;
}
int countbit(int x) {
int res = 0;
for (int i = 0; i < m; i++)
if ((x >> i) & 1) res++;
return res;
}
long long cc[(1 << 20) + 100];
long long pow2[(1 << 20) + 100];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
cc[(~a) & kk]++;
}
computeS(cc);
pow2[0] = 1LL;
for (int i = 1; i < (1 << m); i++) pow2[i] = (pow2[i - 1] * 2) % e9;
long long res = 0;
for (int i = 0; i < (1 << m); i++)
res = (res + pow2[cc[i]] * powm(countbit(i)) + e9) % e9;
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 5;
const int mod = 1e9 + 7;
const int N = 20;
long long a[maxn], dp[maxn], p[maxn];
int main() {
p[0] = 1;
for (int i = 1; i < maxn; i++) {
p[i] = p[i - 1] * 2 % mod;
}
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
dp[a[i]]++;
}
int s = 1 << N;
for (int j = 0; j < N; j++)
for (int i = 0; i < s; i++)
if (!(i >> j & 1)) dp[i] += dp[i ^ (1 << j)];
for (int i = 0; i < s; i++) {
dp[i] = (p[dp[i]] - 1 + mod) % mod;
}
long long ans = 0;
for (int i = 0; i < s; i++) {
int cnt = 0;
for (int j = 0; j < N; j++) {
cnt += (i >> j & 1);
}
long long f = (cnt % 2 ? -1 : 1);
ans = (ans + f * dp[i] % mod + mod) % mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INFL = (int)1e9;
const long long int INFLL = (long long int)1e18;
const double INFD = numeric_limits<double>::infinity();
const double PI = 3.14159265358979323846;
bool nearlyeq(double x, double y) { return abs(x - y) < 1e6; }
long long int rndf(double x) {
return (long long int)(x + (x >= 0 ? 0.5 : -0.5));
}
long long int floorsqrt(double x) {
long long int m = (long long int)sqrt(x);
return m + (m * m <= (long long int)(x) ? 0 : -1);
}
long long int ceilsqrt(double x) {
long long int m = (long long int)sqrt(x);
return m + ((long long int)x <= m * m ? 0 : 1);
}
long long int rnddiv(long long int a, long long int b) {
return (a / b + (a % b * 2 >= b ? 1 : 0));
}
long long int ceildiv(long long int a, long long int b) {
return (a / b + (a % b == 0 ? 0 : 1));
}
long long int gcd(long long int m, long long int n) {
if (n == 0)
return m;
else
return gcd(n, m % n);
}
namespace mod_op {
const long long int MOD = (long long int)1e9 + 7;
class modll {
private:
long long int val;
inline long long int modify(long long int x) {
long long int ret = x % MOD;
if (ret < 0) ret += MOD;
return ret;
}
inline long long int inv(long long int x) {
if (x == 0)
return 1 / x;
else if (x == 1)
return 1;
else
return modify(inv(MOD % x) * modify(-MOD / x));
}
public:
modll(long long int init = 0) {
val = modify(init);
return;
}
modll(const modll &another) {
val = another.val;
return;
}
inline modll &operator=(const modll &another) {
val = another.val;
return *this;
}
inline modll operator+(const modll &x) { return modify(val + x.val); }
inline modll operator-(const modll &x) { return modify(val - x.val); }
inline modll operator*(const modll &x) { return modify(val * x.val); }
inline modll operator/(const modll &x) { return modify(val * inv(x.val)); }
inline modll &operator+=(const modll &x) {
val = modify(val + x.val);
return *this;
}
inline modll &operator-=(const modll &x) {
val = modify(val - x.val);
return *this;
}
inline modll &operator*=(const modll &x) {
val = modify(val * x.val);
return *this;
}
inline modll &operator/=(const modll &x) {
val = modify(val * inv(x.val));
return *this;
}
inline bool operator==(const modll &x) { return val == x.val; }
inline bool operator!=(const modll &x) { return val != x.val; }
friend inline istream &operator>>(istream &is, modll &x) {
is >> x.val;
return is;
}
friend inline ostream &operator<<(ostream &os, const modll &x) {
os << x.val;
return os;
}
long long int get_val() { return val; }
};
modll pow(modll n, long long int p) {
modll ret;
if (p == 0)
ret = 1;
else if (p == 1)
ret = n;
else {
ret = pow(n, p / 2);
ret *= ret;
if (p % 2 == 1) ret *= n;
}
return ret;
}
vector<modll> facts;
inline void make_facts(int n) {
if (facts.empty()) facts.push_back(modll(1));
for (int i = (int)facts.size(); i <= n; ++i)
facts.push_back(modll(facts.back() * (long long int)i));
return;
}
vector<modll> ifacts;
vector<modll> invs;
inline void make_invs(int n) {
if (invs.empty()) {
invs.push_back(modll(0));
invs.push_back(modll(1));
}
for (int i = (int)invs.size(); i <= n; ++i) {
invs.push_back(invs[(int)MOD % i] * ((int)MOD - (int)MOD / i));
}
return;
}
inline void make_ifacts(int n) {
make_invs(n);
if (ifacts.empty()) ifacts.push_back(modll(1));
for (int i = (int)ifacts.size(); i <= n; ++i)
ifacts.push_back(modll(ifacts.back() * invs[i]));
return;
}
modll combination(long long int n, long long int r) {
if (n >= r && r >= 0) {
modll ret;
make_facts((int)n);
make_ifacts((int)n);
ret = facts[(unsigned)n] * ifacts[(unsigned)r] * ifacts[(unsigned)(n - r)];
return ret;
} else
return 0;
}
modll get_fact(long long int n) {
make_facts((int)n);
return facts[(int)n];
}
modll get_ifact(long long int n) {
make_ifacts((int)n);
return ifacts[(int)n];
}
long long int disc_log(modll a, modll b) {
long long int ret = -1;
long long int m = ceilsqrt(MOD);
unordered_map<long long int, long long int> mp;
modll x = 1;
for (int i = 0; i < (int)m; i++) {
mp[x.get_val()] = i;
x *= a;
}
x = modll(1) / pow(a, m);
modll k = b;
for (int i = 0; i < (int)m; i++) {
if (mp.find(k.get_val()) == mp.end())
k *= x;
else {
ret = i * m + mp[k.get_val()];
break;
}
}
return ret;
}
} // namespace mod_op
using namespace mod_op;
namespace Zeta_and_Mobius_transform {
vector<modll> Zeta_trans_rev(vector<modll> f) {
int n = f.size();
int digit = int(rndf(log2(n)));
vector<modll> ret = f;
for (int i = 0; i < (int)digit; i++) {
int x = 1 << i;
for (int j = 0; j < (int)n; j++) {
if (!(j & x)) ret[j] += ret[j | x];
}
}
return ret;
}
int legal_size_of(int n) {
int ret = 1 << (int)log2(n);
if (ret < n) ret <<= 1;
return ret;
}
} // namespace Zeta_and_Mobius_transform
using namespace Zeta_and_Mobius_transform;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
int n;
cin >> n;
vector<modll> x(legal_size_of(1000000));
for (int i = 0; i < (int)n; i++) {
int a;
cin >> a;
x[a] += 1;
}
vector<modll> y = Zeta_trans_rev(x);
modll ans = 0;
for (int i = 0; i < (int)y.size(); i++) {
int cnt = 0;
for (int j = 0; j < (int)21; j++) {
cnt += (i & (1 << j) ? 1 : 0);
}
ans += pow(modll(-1), cnt) * pow(modll(2), y[i].get_val());
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
const int num = 1000000, mo = 1e9 + 7;
int a[num + 5], f[num + 5], i, j, n, x, ans = 0;
int main() {
scanf("%d\n", &n);
for (i = 1; i <= n; ++i) scanf("%d", &x), f[x]++;
for (a[0] = i = 1; i <= n; ++i) a[i] = (a[i - 1] << 1) % mo;
for (j = 0; j < 20; ++j)
for (i = num; i >= 0; --i)
if (i & (1 << j)) (f[1 << j ^ i] += f[i]) %= mo;
for (i = num; i >= 0; --i) {
x = 1;
for (j = 0; j < 20; ++j)
if (i & (1 << j)) x = -x;
(ans += 1ll * x * (a[f[i]] - 1)) %= mo;
}
printf("%d\n", (ans + mo) % mo);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, t[1111111], u[1111111];
int p2[1111111];
long long ans = 0;
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); i++) {
int a;
scanf("%d", &a);
t[a]++;
}
for (int i = (0); i <= (19); i++) {
for (int j = (0); j <= (((1 << 20) - 1)); j++) {
u[j] += t[j];
if (j & (1 << i)) u[j - (1 << i)] += t[j];
}
for (int j = (0); j <= (((1 << 20) - 1)); j++) {
t[j] = u[j];
u[j] = 0;
}
}
p2[0] = 1;
for (int i = (1); i <= (n); i++) p2[i] = p2[i - 1] * 2 % 1000000007;
int res = 0;
for (int i = (0); i <= (((1 << 20) - 1)); i++) {
int cb = 0;
for (int j = (0); j <= (19); j++) cb += (i & (1 << j)) >> j;
if (cb % 2 == 0)
res += p2[t[i]] - 1;
else
res -= p2[t[i]] - 1;
res = (res % 1000000007 + 1000000007) % 1000000007;
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 29;
const long long LINF = 1LL << 60;
const double inf = 1e15;
long long mod = 1e9 + 7;
char READ_DATA;
int SIGNAL_INPUT;
template <typename Type>
inline Type ru(Type &v) {
SIGNAL_INPUT = 1;
while ((READ_DATA = getchar()) < '0' || READ_DATA > '9')
if (READ_DATA == '-')
SIGNAL_INPUT = -1;
else if (READ_DATA == EOF)
return EOF;
v = READ_DATA - '0';
while ((READ_DATA = getchar()) >= '0' && READ_DATA <= '9')
v = v * 10 + READ_DATA - '0';
v *= SIGNAL_INPUT;
return v;
}
inline long long modru(long long &v) {
long long p = 0;
SIGNAL_INPUT = 1;
while ((READ_DATA = getchar()) < '0' || READ_DATA > '9')
if (READ_DATA == '-')
SIGNAL_INPUT = -1;
else if (READ_DATA == EOF)
return EOF;
p = v = READ_DATA - '0';
while ((READ_DATA = getchar()) >= '0' && READ_DATA <= '9') {
v = (v * 10 + READ_DATA - '0') % mod;
p = (p * 10 + READ_DATA - '0') % (mod - 1);
}
v *= SIGNAL_INPUT;
return p;
}
template <typename A, typename B>
inline char ru(A &x, B &y) {
if (ru(x) == EOF) return EOF;
ru(y);
return 2;
}
template <typename A, typename B, typename C>
inline char ru(A &x, B &y, C &z) {
if (ru(x) == EOF) return EOF;
ru(y);
ru(z);
return 3;
}
template <typename A, typename B, typename C, typename D>
inline char ru(A &x, B &y, C &z, D &w) {
if (ru(x) == EOF) return EOF;
ru(y);
ru(z);
ru(w);
return 4;
}
struct Edge {
int u, v, next;
long long w, cap, flow;
Edge(int _u = 0, int _v = 0, int nxt = -1, long long _w = 1,
long long _cap = 0) {
u = _u;
v = _v;
w = _w;
cap = _cap;
flow = 0;
next = nxt;
}
int operator<(const Edge &b) const { return w < b.w; }
};
const int maxn = 1e6 + 10, N = 2e6 + 1;
double eps = 1e-7, pi = acos(-1.0);
unsigned long long seed = 131, smod = (1LL << 32) - 267;
const int BIT = 1 << 20;
int bitcnt(int x) {
int ans = 0;
while (x) {
ans += (x & 1);
x >>= 1;
}
return ans;
}
long long qkpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) (ans *= a) %= mod;
(a *= a) %= mod;
b >>= 1;
}
return ans;
}
long long f[20][BIT], n, x;
int main() {
ru(n);
while (n--) {
ru(x);
f[0][x]++;
if (x & 1) f[0][x ^ 1]++;
}
for (register int i = 1; i < 20; ++i) {
for (register int s = 0; s < BIT; ++s) {
if ((s >> i) & 1) {
f[i][s] = f[i - 1][s];
} else
f[i][s] = f[i - 1][s] + f[i - 1][s | (1 << i)];
}
}
long long ans = 0;
for (register int s = 0; s < BIT; ++s) {
if (bitcnt(s) & 1) {
(ans -= qkpow(2, f[19][s])) %= mod;
if (ans < 0) ans += mod;
} else
(ans += qkpow(2, f[19][s])) %= mod;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
const double INFF = 1e100;
const double eps = 1e-8;
const int mod = 1000000007;
const int NN = 100005;
const int MM = 1000010;
int dp[20][1 << 20];
int a[1 << 20];
int q_pow(int x, int n, long long mod) {
long long ans = 1, xx = x;
for (; n > 0; n >>= 1) {
if (n & 1) ans = ans * xx % mod;
xx = xx * xx % mod;
}
return (int)ans;
}
int main() {
int n, i, j, mask = 1 << 20;
int ans, t, tt;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(dp, 0, sizeof(dp));
for (i = 1; i <= n; i++) {
if (a[i] & 1) {
dp[0][a[i]]++;
dp[0][a[i] ^ 1]++;
} else {
dp[0][a[i]]++;
}
}
for (i = 0; i < 19; i++)
for (j = 0; j < mask; j++) {
t = 1 << (i + 1);
if (j & t) {
dp[i + 1][j] += dp[i][j];
dp[i + 1][j - t] += dp[i][j];
} else {
dp[i + 1][j] += dp[i][j];
}
}
ans = 0;
for (j = 0; j < mask; j++) {
t = 1;
for (i = 0; i < 20; i++)
if ((1 << i) & j) t = -t;
tt = q_pow(2, dp[19][j], mod);
tt--;
if (tt < 0) tt += mod;
ans += t * tt;
if (ans >= mod) ans -= mod;
if (ans < 0) ans += mod;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, dp[1 << 20], num[1 << 20], mi[1 << 20];
long long ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
dp[x]++;
}
mi[0] = 1;
for (int i = 1; i < 1 << 20; i++)
num[i] = num[i >> 1] + (i & 1), mi[i] = mi[i - 1] * 2 % 1000000007;
for (int j = 1; j <= 20; j++)
for (int i = 0; i < 1 << 20; i++)
if (i & (1 << j - 1)) dp[i ^ (1 << j - 1)] += dp[i];
for (int i = 0; i < 1 << 20; i++) {
if (num[i] & 1)
ans = (ans - 1ll * mi[dp[i]] + 1) % 1000000007;
else
ans = (ans + 1ll * mi[dp[i]] - 1) % 1000000007;
}
printf("%lld", (ans + 1000000007) % 1000000007);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
static int N;
static long long ans = 0, bin[1000007] = {1}, dp[1000007];
int main() {
for (int i = 1; i < 1000007; i++) bin[i] = bin[i - 1] * 2 % MOD;
scanf("%d", &N);
for (int i = 0, x; i < N; i++) scanf("%d", &x), dp[x]++;
for (int j = 0; j < 25; j++)
for (int i = 0; i < 1000007; i++)
if ((1 << j) & i) (dp[i ^ (1 << j)] += dp[i]) %= MOD;
for (int i = 0; i < 1000007; i++) {
int sign = 1;
for (int j = 0; j < 25; j++)
if ((1 << j) & i) sign = -sign;
(ans += sign * (bin[dp[i]] - 1) % MOD + MOD) %= MOD;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 3e6 + 5;
int bit[N], pw[N], f[N];
char IN[300000], *SS = IN, *TT = IN;
inline int read() {
int now = 0;
register char c = getchar();
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); now = now * 10 + c - '0', c = getchar())
;
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 maxN = 2e6 + 5;
const int maxLOG = 20;
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long sq(long long x) { return (x * x) % MOD; }
long long modP(long long a, long long b) {
return (!b ? 1 : (sq(modP(a, b / 2)) * (b % 2 ? a : 1)) % MOD);
}
long long sub[maxN], dp[maxN], a[maxN];
long long NT(long long x) { return (1 << maxLOG) - x - 1; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
sub[NT(a[i])] += 1;
}
for (long long i = 0; i < maxLOG; i++) {
for (long long j = 0; j < maxN; j++) {
if (j & (1 << i)) {
sub[j] += sub[j ^ (1 << i)];
sub[j] %= MOD;
}
}
}
for (int i = 0; i < maxN; i++) {
if (i < NT(i)) swap(sub[i], sub[NT(i)]);
}
long long res = 0;
long long mx = *max_element(a, a + n);
for (int i = 0; i <= mx; i++) {
res += (__builtin_popcount(i) % 2 ? -1 : +1) * (modP(2, sub[i]) - 1);
while (res < MOD) res += MOD;
res %= MOD;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int N;
int A[1 << 20], f[1 << 20], g[1 << 20];
long long ans, pw[1 << 20];
int main(void) {
scanf("%d", &N);
pw[0] = 1;
for (int i = 1; i <= N; i++) {
pw[i] = (pw[i - 1] * 2) % mod;
}
for (int i = 0; i < N; i++) {
scanf("%d", &A[i]);
f[A[i]]++;
}
for (int i = 0; i < 20; i++) {
for (int j = (1 << 20) - 1; j >= 0; j--) {
if ((j & (1 << i)) == 0) {
f[j] += f[j | (1 << i)];
}
}
}
for (int i = 0; i < (1 << 20); i++) {
g[i] = __builtin_popcount(i);
if (g[i] & 1)
g[i] = -1;
else
g[i] = 1;
ans += g[i] * pw[f[i]];
ans %= mod;
if (ans < 0) ans += mod;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
const int N = (int)1e6 + 7;
const int inf = (int)1e9 + 7;
const int mod = (int)1e9 + 7;
const long long linf = (long long)1e18 + 7;
const int dx[] = {-1, 0, 1, 0, 1, -1, -1, 1};
const int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
using namespace std;
void add(int &x, int y) {
x += y;
if (x >= mod)
x -= mod;
else if (x < 0)
x += mod;
}
int sum(int x, int y) {
add(x, y);
return x;
}
int bp(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = res * 1ll * x % mod;
x = x * 1ll * x % mod, y >>= 1;
}
return res;
}
int n;
int dp[1 << 20];
int main() {
ios_base ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = (1); i <= (n); i++) {
int x;
cin >> x;
dp[x]++;
}
for (int i = (0); i <= (19); i++) {
for (int mask = ((1 << 20) - 1); mask >= (0); mask--) {
if (mask & (1 << i)) dp[mask ^ (1 << i)] += dp[mask];
}
}
int ans = 0;
for (int mask = (0); mask <= ((1 << 20) - 1); mask++) {
if (__builtin_popcount(mask) & 1)
add(ans, -bp(2, dp[mask]));
else
add(ans, bp(2, dp[mask]));
}
cout << ans;
exit(0);
}
|
#include <bits/stdc++.h>
const double EPS = 1e-10;
const long long int MOD = 1000000007ll;
const long long int mod1 = 1000000009ll;
const long long int mod2 = 1100000009ll;
const double PI = 3.14159265359;
int INF = 2147483645;
long long int INFINF = 9223372036854775807;
int debug = 0;
using namespace std;
long long int bit_count(long long int _x) {
long long int _ret = 0;
while (_x) {
if (_x % 2 == 1) _ret++;
_x /= 2;
}
return _ret;
}
long long int bit(long long int _mask, long long int _i) {
return (_mask & (1 << _i)) == 0 ? 0 : 1;
}
long long int powermod(long long int _a, long long int _b, long long int _m) {
long long int _r = 1;
while (_b) {
if (_b % 2 == 1) _r = (_r * _a) % _m;
_b /= 2;
_a = (_a * _a) % _m;
}
return _r;
}
long long int add(long long int a, long long int b) {
long long int x = a + b;
if (x >= MOD) x -= MOD;
return x;
}
long long int sub(long long int a, long long int b) {
long long int x = a - b;
if (x < 0) x += MOD;
return x;
}
long long int mul(long long int a, long long int b) {
long long int x = a * b;
x %= MOD;
return x;
}
int n;
int a[1000010];
int dp[21][1100010];
int logM = 20;
int M = (1 << logM) - 1;
int main() {
srand(time(NULL));
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) dp[0][a[i]]++;
for (int i = 1; i <= logM; i++) {
for (int j = 0; j <= M; j++) {
if (bit(j, i - 1))
dp[i][j] += dp[i - 1][j];
else
dp[i][j] += dp[i - 1][j] + dp[i - 1][j | (1 << (i - 1))];
if (dp[i][j] > MOD) dp[i][j] -= MOD;
}
}
long long int ans = powermod(2, n, MOD);
for (int i = 1; i < (1 << logM); i++) {
if (bit_count(i) % 2 == 0) {
ans = add(ans, powermod(2, dp[logM][i], MOD));
} else {
ans = sub(ans, powermod(2, dp[logM][i], MOD));
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int N = (1 << 20) + 100;
bool one(int mask, int i) { return mask & (1 << i); }
int n, a[N], d[N];
int p[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]) 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;
const int maxn = 2e6 + 7;
const int inf = 2e9;
const long long inff = 1e18;
const long long mod = 1e9 + 7;
int pow2[maxn];
int dp[maxn];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
pow2[0] = 1;
for (int i = 1; i <= 1000000; i++) pow2[i] = pow2[i - 1] * 2 % mod;
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
dp[x]++;
}
for (int j = 0; j < 20; j++)
for (int i = 0; i < (1 << 20); i++) {
if ((i >> j) & 1 ^ 1) dp[i] += dp[i ^ (1 << j)];
}
int ans = 0;
for (int i = 0; i < (1 << 20); i++) {
if (__builtin_popcount(i) & 1)
ans = (ans + mod - pow2[dp[i]]) % mod;
else
ans = (ans + pow2[dp[i]]) % mod;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int LN = 20;
const int MOD = 1000000007;
int n;
int arr[1 << LN];
int dp[1 << LN][LN + 1];
int f[1 << LN], p[1 << LN];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", arr + i);
++dp[arr[i]][0];
}
for (int mask = (1 << LN) - 1; mask >= 0; mask--) {
for (int i = 0; i < LN; i++) {
if (mask & (1 << i))
dp[mask][i + 1] = dp[mask][i];
else
dp[mask][i + 1] = dp[mask][i] + dp[mask | (1 << i)][i];
}
f[mask] = dp[mask][LN];
}
p[0] = 1;
for (int i = 1; i < (1 << LN); i++) {
p[i] = (2LL * p[i - 1]) % MOD;
}
for (int i = 0; i < (1 << LN); i++) {
p[i] = (p[i] - 1 + MOD) % MOD;
}
int ans = 0;
for (int i = 0; i < (1 << LN); i++) {
if (__builtin_popcount(i) & 1)
ans = (ans - p[f[i]] + MOD) % MOD;
else
ans = (ans + p[f[i]]) % MOD;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long inline read() {
long long num = 0, neg = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') neg = -1;
c = getchar();
}
while (isdigit(c)) {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
return num * neg;
}
const long long maxn = 1e6 + 10, mod = 1e9 + 7;
long long n, a[maxn], f[1 << 20], g[1 << 20], sum[1 << 20];
long long Pow(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) ans = ans * x % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long Get(long long x) {
long long num = 0;
while (x) {
if (x & 1) num++;
x >>= 1;
}
return num;
}
signed main() {
n = read();
for (long long i = 1; i <= n; i++) a[i] = read(), f[a[i]]++;
for (long long i = 0; i < 20; i++)
for (long long j = (1 << 20) - 1; j >= 0; j--)
if (!(j & (1 << i))) f[j] = f[j] + f[j | (1 << i)];
for (long long i = 0; i < (1 << 20); i++)
g[i] = ((Pow(2, f[i]) - 1) % mod + mod) % mod;
for (long long i = 0; i < (1 << 20); i++) sum[i] = (Get(i) & 1) ? -1 : 1;
long long ans = 0;
for (long long i = 0; i < (1 << 20); i++)
ans = (ans + (sum[i] * g[i] % mod + mod) % mod) % mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9, mod = 1e9 + 7;
const int N = 2e6 + 5;
int P[N], n, a[N], i, j, k, m, dp[N];
long long ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
dp[a[i]]++;
}
P[0] = 1;
for (int i = 1; i <= n; i++) P[i] = P[i - 1] * 2 % mod;
for (int j = 0; j <= 19; j++)
for (int i = (1 << 20) - 1; i >= 0; i--)
if ((i & (1 << j))) dp[i - (1 << j)] += dp[i];
for (int i = (1 << 20) - 1; i >= 0; i--) {
int t = __builtin_popcount(i);
if (t % 2)
ans = (ans - P[dp[i]] + 1 + mod) % mod;
else
ans = (ans + P[dp[i]] - 1) % mod;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (1e9) + 7;
int modPow(int b, int e) {
if (e == 0)
return 1;
else if (e == 1)
return b;
return 1ll * modPow(1ll * b * b % MOD, e >> 1) * modPow(b, e & 1) % MOD;
}
int n, ans, f[1 << 20];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0, x; i < n; i++) {
cin >> x;
f[x]++;
}
for (int j = 0; j < 20; j++)
for (int mask = (1 << 20) - 1; mask >= 0; mask--) {
if (!(mask >> j & 1)) f[mask] = (f[mask] + f[mask | 1 << j]) % MOD;
}
for (int mask = 0; mask < 1 << 20; mask++) {
int bits = __builtin_popcount(mask);
if (bits & 1)
ans = (ans - modPow(2, f[mask])) % MOD;
else
ans = (ans + modPow(2, f[mask])) % MOD;
}
cout << (ans + MOD) % MOD;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<vector<int>> dp((1 << 20), vector<int>(21, 0));
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
dp[a][0]++;
}
const long long mod = 1000000007;
vector<long long> p(n + 1, 1);
for (int i = 1; i <= n; i++) p[i] = (p[i - 1] * 2) % mod;
for (int i = (1 << 20) - 1; i >= 0; i--) {
for (int j = 1; j <= 20; j++) {
dp[i][j] = dp[i][j - 1];
if ((i & (1 << (j - 1))) == 0) dp[i][j] += dp[i + (1 << (j - 1))][j];
}
}
long long res = 0;
for (int i = 0; i < (1 << 20); i++) {
int c = __builtin_popcount(i);
if (c & 1)
res = (res - p[dp[i][20]] + mod) % mod;
else
res = (res + p[dp[i][20]]) % mod;
}
printf("%I64d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, mxN = 1e6 + 3;
long long n, dp[(1 << 20)];
const int k = 20, e = (1 << 20);
long long pc(int x) {
long long res = 0;
while (x > 0) res += (x & 1), x /= 2;
return res;
}
long long po(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % mod;
x = x * x % mod;
y /= 2;
}
return res;
}
int main() {
cin >> n;
for (int i = 0, x; i < n; i++) {
cin >> x;
dp[x]++;
}
for (int i = 0; i < k; i++)
for (long long j = 0; j < e; j++) {
int g = j ^ (1 << i);
if (j & (1 << i)) dp[g] += dp[j];
}
long long ans = 0;
for (int i = 0; i < e; i++) {
long long cnt = po(2, dp[i]) - 1;
ans = (ans + ((pc(i) % 2) ? -cnt : cnt)) % mod;
}
cout << (ans + mod) % mod;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const double pi = acos(-1.0);
const double eps = 1e-9;
const int mod = inf + 7;
int n, x, w[2000100], p[2000100];
long long res;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
w[x] = w[x] + 1;
}
for (int i = 0; i <= 20; i++)
for (int mask = 0; mask < (1 << 20); mask++)
if (mask & (1 << i)) w[mask ^ (1 << i)] += w[mask];
p[0] = 1;
for (int i = 1; i <= n; i++) p[i] = p[i - 1] * 2 % mod;
for (int mask = 0; mask < (1 << 20); mask++) {
int c = 1;
for (int i = 0; i < 20; i++)
if (mask & (1 << i)) c = -c;
res = (res + c * p[w[mask]] + mod) % mod;
}
printf("%I64d", res);
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;
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 = 20; i >= 1; i--)
for (int j = mx; j >= 0; j--)
if (!(j & (1 << (i - 1)))) dp[j] += dp[j | (1 << (i - 1))];
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;
int All, n, i, j, k;
int a[2000005], b[2000005], f[2000005];
long long two[2000005], ans, tmp;
int main() {
All = (1 << 20) - 1;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]), b[a[i]]++;
two[0] = 1;
for (i = 1; i <= n; i++) two[i] = two[i - 1] * 2 % Mo;
for (i = 0; i < 20; i++)
for (j = 0; j <= All; j++)
if (j & (1 << i)) b[j - (1 << i)] += b[j], f[j]++;
for (i = 0; i <= All; i++) {
tmp = (two[b[i]] + Mo - 1) % Mo;
if (f[i] & 1)
ans = (ans + Mo - tmp) % Mo;
else
ans = (ans + tmp) % Mo;
}
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[1 << 20], pow2[1000009];
void pre() {
pow2[0] = 1;
for (int i = int(1); i <= int(1000000); i++)
pow2[i] = (pow2[i - 1] * 2) % 1000000007;
}
int main() {
pre();
int n;
scanf("%d", &n);
for (int i = int(0); i <= int(n - 1); i++) {
int p;
scanf("%d", &p);
cnt[p]++;
}
for (int i = int(0); i <= int(19); i++) {
for (int j = int((1 << 20) - 1); j >= int(0); j--) {
if (j & (1 << i)) cnt[j - (1 << i)] += cnt[j];
}
}
int ans = 0;
for (int i = int(0); i <= int((1 << 20) - 1); i++) {
int bits = 0, temp = i;
while (temp > 0) {
bits++;
temp -= temp & -temp;
}
if (bits % 2 == 0)
ans = (ans + pow2[cnt[i]]) % 1000000007;
else
ans = (ans - pow2[cnt[i]] + 1000000007) % 1000000007;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, MOD = 1e9 + 7, LOG = 21;
int n, a[N], dp[2 * N][LOG];
long long jv;
long long power(long long a, long long b) {
long long res = 1;
for (; b; b /= 2) {
if (b % 2) {
res *= a;
res %= MOD;
}
a *= a;
a %= MOD;
}
return res;
}
void read_input() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
dp[a[i]][0]++;
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
read_input();
for (int j = 1; j < LOG; j++) {
for (int i = 0; i < N; i++) {
dp[i][j] = dp[i][j - 1];
if ((i & (1 << (j - 1))) == 0) {
dp[i][j] += dp[i + (1 << (j - 1))][j - 1];
}
dp[i][j] %= MOD;
}
}
for (int i = 0; i < N; i++) {
if (__builtin_popcount(i) % 2) {
jv -= power(2, dp[i][LOG - 1]) - 1;
} else {
jv += power(2, dp[i][LOG - 1]) - 1;
}
jv %= MOD;
}
cout << (jv + MOD) % MOD;
return 0;
}
|
#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 = 0; j <= lim; ++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;
int n, a[4000010], F[4000010], limit, ans = 0;
void FWT_AND(int *A, int type) {
for (register int mid = 1; mid < limit; mid <<= 1) {
for (register int R = (mid << 1), j = 0; j < limit; j += R) {
for (register int k = 0; k < mid; k++) {
if (type)
A[j + k] = (A[j + k] + A[j + k + mid]) % 1000000007;
else
A[j + k] = (A[j + k] - A[j + k + mid] + 1000000007) % 1000000007;
}
}
}
}
int fpm(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = 1ll * res * x % 1000000007;
x = 1ll * x * x % 1000000007;
y >>= 1;
}
return res;
}
int main() {
scanf("%d", &n);
limit = (1 << 20);
for (register int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (register int i = 1; i <= n; ++i) F[a[i]]++;
FWT_AND(F, 1);
for (register int i = 0; i < limit; ++i) {
int cnt = 0, x = i;
while (x) {
cnt += (x & 1);
x >>= 1;
}
if (cnt & 1)
ans = (ans - fpm(2, F[i]) + 1000000007) % 1000000007;
else
ans = (ans + fpm(2, F[i])) % 1000000007;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, a[1000005], sos[(1 << 20) + 100], mod = 1e9 + 7;
long long bigmod(long long a, long long b) {
if (b == 0) return 1;
long long x = bigmod(a, b / 2);
x = (x * x) % mod;
if (b % 2 == 1) x *= a;
return x % mod;
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
int nn = (1 << 20);
for (int i = 0; i < n; i++) {
cin >> a[i];
sos[a[i]]++;
}
for (int i = 0; i < 20; ++i)
for (int mask = 0; mask < (1 << 20); ++mask) {
if (!(mask & (1 << i))) sos[mask] += sos[mask ^ (1 << i)];
}
for (int i = 0; i < 8; i++) {
}
long long ans = 0;
for (int mask = 1; mask < (1 << 20); mask++) {
int p = __builtin_popcount(mask);
if (p % 2 == 1) {
ans += bigmod(2, sos[mask]) - 1;
ans += mod;
ans %= mod;
} else {
ans -= (bigmod(2, sos[mask]) - 1);
ans += mod;
ans %= mod;
}
}
long long ans2 = 0;
ans2 = bigmod(2, n) - 1;
ans2 += mod;
ans2 %= mod;
ans2 -= ans;
ans2 += mod;
ans2 %= mod;
cout << ans2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int st[2000055], res[2000055];
int x, n;
int b[1000005];
int a[2000055], p[2000055];
int f[1000055][21];
int ansW[1000055];
int g[1000055][22];
int ger[1000005];
int add(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
void precalc() {
for (int i = 1000000; i >= 0; --i) {
f[i][20] = a[i];
for (int j = 20; j > 0; --j) {
f[i][j - 1] += f[i][j];
if (i & (1 << (j - 1))) f[i - (1 << (j - 1))][j - 1] += f[i][j];
}
}
for (int i = 0; i <= 1000000; ++i) p[i] = f[i][0];
}
bool bit(int x, int y) {
x = x & (1 << y);
return (x > 0);
}
void solve() {
int ret = 0;
for (int i = 1; i < (1 << n); ++i) {
int x = (1 << 20) - 1;
for (int j = 0; j < n; ++j)
if (bit(i, j)) x &= b[j];
ansW[x]++;
ret += (x == 0);
}
cout << ret << endl;
}
int main() {
scanf("%d", &n);
int mx = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &x);
b[i] = x;
if (x != 0) a[x]++;
mx = max(mx, x + 1);
}
st[0] = 1;
precalc();
for (int i = 1; i <= 2 * n; ++i) st[i] = st[i - 1] * 2 % MOD;
int ret = 1;
for (int i = 0; i < n; ++i) add(ret, ret);
int ans = 0;
for (int i = mx; i >= 1; --i) {
res[i] = (st[p[i]] - 1 + MOD) % MOD;
for (int j = 0; j < 20; ++j)
if (j % 2)
res[i] = (res[i] + g[i][j]) % MOD;
else
res[i] = (res[i] - g[i][j] + MOD) % MOD;
if (res[i] < 0) res[i] += MOD;
g[i][20] = res[i];
for (int j = 20; j > 0; --j) {
g[i][j - 1] = (g[i][j - 1] - g[i][j] + MOD) % MOD;
if (i & (1 << (j - 1)))
g[i - (1 << (j - 1))][j - 1] =
(g[i - (1 << (j - 1))][j - 1] - g[i][j] + MOD) % MOD;
}
ans = (ans + res[i]) % MOD;
if (ans < 0) ans += MOD;
}
ret = (ret - 1 + MOD) % MOD;
ret = ret - ans + MOD;
ret %= MOD;
printf("%d\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int max_n = 1e6 + 5;
int dp[max_n];
long long f[21], b[max_n];
int main() {
int n;
scanf("%d", &n);
memset(dp, 0, sizeof dp);
int mx = 0;
b[0] = 1;
for (int i = 1; i <= n; i++) b[i] = (b[i - 1] << 1) % mod;
for (int i = 1; i <= n; i++) {
int a_i;
scanf("%d", &a_i);
mx = max(mx, a_i);
dp[a_i]++;
}
for (int j = 0; j <= 20; j++) {
for (int i = 1; i <= mx; i++)
if (dp[i]) {
if (i & (1 << j)) {
dp[i ^ (1 << j)] += dp[i];
}
}
}
for (int i = 0; i <= mx; i++) {
int cnt = 0;
for (int j = 0; j <= 20; j++) {
if (i & (1 << j)) cnt++;
}
f[cnt] = (f[cnt] + (b[dp[i]] - 1) % mod) % mod;
}
long long sum = 0;
for (int i = 0; i <= 20; i++) {
if (i % 2 == 0)
sum = (sum + f[i]) % mod;
else
sum = (sum - f[i] + mod) % mod;
}
printf("%lld\n", sum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fastMax(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ y; }
int fastMin(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ x; }
const long long int N = 20;
const long long int MAXN = 1 << N;
const long long int MOD = 1e9 + 7;
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) % MOD;
x = (x * x) % MOD;
y >>= 1;
}
return res;
}
long long int A[MAXN], F[MAXN];
void solve() {
long long int n;
cin >> n;
for (int i = (1); i <= (n); ++i) {
cin >> A[i];
F[A[i]]++;
}
for (int i = (0); i <= (N - 1); ++i) {
for (int mask = (0); mask <= (MAXN - 1); ++mask) {
if (mask & (1 << i)) F[mask ^ (1 << i)] += F[mask];
}
}
long long int ans = 0;
for (int i = (0); i <= (MAXN - 1); ++i) {
long long int b = __builtin_popcount(i);
long long int cnt = power(2, F[i]);
if (b & 1) cnt = MOD - cnt;
ans += cnt;
ans %= MOD;
}
cout << ans << endl;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t;
t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mk = 1 << 21;
const long long logn = 29;
const long long mod = 1e9 + 7;
long long n, num[mk];
long long f[mk], qpow[mk], g[mk], ans;
signed main() {
cin >> n;
int mx = 1000000;
qpow[0] = 1;
for (int a, i = 1; i <= n; i++) {
scanf("%d", &a), f[a]++;
qpow[i] = (qpow[i - 1] << 1) % mod;
}
for (int i = 0; i <= 20; i++) {
for (int j = 1; j <= mx; j++)
if (j & (1 << i)) f[j ^ (1 << i)] += f[j];
}
for (int i = 0; i <= mx; i++) {
num[i] = num[i >> 1] + (i & 1);
g[num[i]] = (g[num[i]] + qpow[f[i]] - 1) % mod;
}
for (int i = 0; i <= 20; i++) {
if (i & 1)
ans = (ans - g[i] + mod) % mod;
else
ans = (ans + g[i]) % mod;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
void add(long long int &x, long long int y) { x = (x + y) % mod; }
const int N = 1 << 20;
long long int dp[N];
long long int p2[N];
void init(void) {
p2[0] = 1;
for (int i = (int)(1); i < (int)(N); i++) {
p2[i] = p2[i - 1] * 2 % mod;
}
}
int main(void) {
init();
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = (int)(0); i < (int)(n); i++) {
cin >> a[i];
dp[a[i]]++;
}
for (int i = (int)(0); i < (int)(20); i++) {
for (int bits = (int)(0); bits < (int)(N); bits++) {
if (bits & 1 << i) {
dp[bits ^ 1 << i] += dp[bits];
}
}
}
for (int bits = (int)(0); bits < (int)(N); bits++) {
dp[bits] = p2[dp[bits]];
}
long long int tot = 0;
for (int bits = (int)(0); bits < (int)(N); bits++) {
long long int tmp = dp[bits];
if (__builtin_popcount(bits) % 2 == 1) {
tmp = mod - tmp;
}
add(tot, tmp);
}
cout << tot << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-6;
template <class T, class U>
ostream& operator<<(ostream& o, const pair<T, U>& v) {
return o << "(" << v.first << ", " << v.second << ")";
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& v) {
o << "{";
for (int i = 0; i < (int)((int)((v).size())); ++i)
o << (i ? ", " : "") << v[i];
return o << "}";
}
void pkuassert(bool t) { t = 1 / t; };
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1};
int dy[] = {1, 0, -1, 0, -1, 1, 1, -1};
int s2i(string& a) {
stringstream ss(a);
int r;
ss >> r;
return r;
}
int n;
int in[1 << 20];
int dp[21][1 << 20];
const long long mod = 1e9 + 7;
long long modpow(long long p, long long n, long long mod) {
long long ret = 1;
while (n) {
if (n & 1) ret = (ret * p) % mod;
p = p * p % mod;
n >>= 1;
}
return ret;
}
const int bit = 20;
int main(int argc, char* argv[]) {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", in + i);
++dp[0][in[i]];
}
for (int i = 0; i < bit; ++i) {
for (int j = 0; j < (int)(1 << bit); ++j) {
if (j & (1 << i)) dp[i + 1][j ^ (1 << i)] += dp[i][j];
dp[i + 1][j] += dp[i][j];
}
}
long long ans = 0;
for (int i = 0; i < (1 << bit); ++i) {
if (__builtin_popcountll(i) % 2)
ans -= modpow(2, dp[bit][i], mod);
else
ans += modpow(2, dp[bit][i], mod);
}
cout << (ans % mod + mod) % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 6, MOD = 1e9 + 7, B = 21;
int n, arr[N], dp[(1 << B)][B], ans = 0, pow2[N];
int M(int x) {
while (x < 0) x += MOD;
return x % MOD;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
pow2[0] = 1;
for (int i = 1; i < N; i++) {
pow2[i] = (pow2[i - 1] * 2) % MOD;
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
dp[arr[i]][B - 1] += 1;
}
for (int i = B - 2; i >= 0; i--) {
for (int j = (1 << B) - 1; j >= 0; j--) {
if (j & (1 << i)) {
dp[j][i] = dp[j][i + 1];
} else {
dp[j][i] = dp[j][i + 1] + dp[j ^ (1 << i)][i + 1];
}
}
}
for (int i = 0; i < (1 << B); i++) {
int cnt = 0, multip = 1;
for (int j = 0; j < B; j++) {
if (i & (1 << j)) cnt++;
}
if (cnt % 2) multip *= (-1);
ans += pow2[dp[i][0]] * multip;
ans = M(ans);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20;
const long long MOD = 1e9 + 7;
int n, m;
long long dp[21][N];
long long g[N];
bool s[N];
void init() {
scanf("%d", &n);
g[0] = 1;
for (int i = 1; i <= n; i++) g[i] = (g[i - 1] << 1LL) % MOD;
int f0;
for (int i = 1; i <= n; i++) {
scanf("%d", &f0);
dp[0][f0]++;
}
}
void work() {
for (int i = 1; i <= 20; i++) {
for (int j = 0; j < N; j++)
if ((j & (1 << (i - 1))) == 0)
dp[i][j] = dp[i - 1][j] + dp[i - 1][j | (1 << (i - 1))];
else
dp[i][j] = dp[i - 1][j], s[j] ^= 1;
}
long long ans = 0;
for (int i = 0; i < N; i++)
ans = (ans + (s[i] ? (-1LL) : 1LL) * g[dp[20][i]] + MOD) % MOD;
printf("%I64d\n", ans);
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, an;
int f[(1 << 20)], h[(1 << 20)];
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &k), f[k]++;
m = (1 << 20) - 1;
for (i = 0; i <= 19; i++)
for (j = 0; j <= m; j++)
if (!(j & (1 << i))) f[j] += f[j | (1 << i)];
h[0] = 1;
for (i = 1; i <= (1 << 20) - 1; i++) h[i] = h[i - 1] * 2 % 1000000007;
for (i = 0; i <= m; i++) {
int s = 0;
for (j = 0; j <= 19; j++) s += i >> j & 1;
if (f[i]) an = ((s & 1 ? -1 : 1) * (h[f[i]] - 1) + an) % 1000000007;
}
if (an < 0) an += 1000000007;
printf("%d\n", an);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5, hgs = 1e9 + 7, K = 19, S = (1 << 20) - 1;
int n, x, f[N], un[N];
void Solution(int Base) {
for (int k = 0; k <= K; ++k)
for (int i = 0; i <= S; ++i)
if (!(i & (1 << k))) f[i] = (f[i] + f[i | (1 << k)] * Base + hgs) % hgs;
}
signed main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &x), ++f[x];
for (int i = 1; i <= n; ++i) un[i] = (un[i - 1] << 1 | 1) % hgs;
Solution(1);
for (int i = 0; i <= S; ++i) f[i] = un[f[i]];
Solution(-1);
printf("%d\n", f[0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int cnt[1 << 20];
inline long long int pow(long long int x, long long int y, long long int p) {
long long int ans = 1;
x = x % p;
while (y > 0) {
if (y & 1) ans = (ans * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return ans;
}
inline long long int invmod(long long int x, long long int p) {
return pow(x, p - 2, p);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n, m;
cin >> n;
m = 20;
long long int rev = (1 << m) - 1;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
cnt[x]++;
}
for (long long int i = 0; i < m; i++)
for (long long int j = rev; j >= 0; j--)
if ((j & (1 << i)) == 0) cnt[j] += cnt[j ^ (1 << i)];
long long int ans = 0;
for (long long int i = 0; i <= rev; i++) {
long long int x = pow(2, cnt[i], 1000000007) - 1;
long long int y = (__builtin_popcount(i)) % 2;
if (y)
ans = (ans - x) % 1000000007;
else
ans = (ans + x) % 1000000007;
}
cout << (ans + 1000000007) % 1000000007;
}
|
#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 mask = 1; mask < mxlg; mask++) {
for (int i = 0; i < MAXX; i++) {
dp[i][mask] = dp[i][mask - 1];
if (!(i & (1 << (mask - 1))))
dp[i][mask] = (dp[i][mask] + dp[i + (1 << (mask - 1))][mask - 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;
const int maxn = 1 << 20;
const int mod = 1e9 + 7;
int A[maxn], dp[maxn];
int main(void) {
int n, a;
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a), dp[a]++;
int all = (1 << 20);
for (int i = 0; i < 20; i++) {
for (int s = all - 1; s >= 0; s--) {
if ((s >> i & 1) == 0) dp[s] += dp[s | (1 << i)];
}
}
A[0] = 1;
for (int i = 1; i < maxn; i++) A[i] = A[i - 1] * 2 % mod;
long long res = 0;
for (int i = 0; i < all; i++) {
int t = 1;
for (int j = 0; j < 20; j++) {
if (i & (1 << j)) t = -t;
}
res = (res + t * (A[dp[i]] - 1) + mod) % mod;
}
cout << res;
}
|
#include <bits/stdc++.h>
long long v[1000005];
long long dp[1000005];
long long f[25];
int n;
int main() {
v[0] = 1;
scanf("%d", &n);
for (int i = 1; i <= 1000000; i++) {
v[i] = (v[i - 1] << 1) % 1000000007;
}
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
dp[x]++;
}
for (int j = 0; j <= 20; j++) {
for (int i = 1; i <= 1000000; i++) {
if (((1 << j) & i)) {
dp[i ^ (1 << j)] += dp[i];
}
}
}
long long ans = 0;
for (int i = 0; i <= 1000000; i++) {
int cnt = 0;
for (int j = 0; j <= 20; j++) {
if ((1 << j) & i) {
cnt++;
}
}
f[cnt] += ((v[dp[i]] - 1) % 1000000007 + 1000000007) % 1000000007;
}
for (int i = 0; i <= 20; i++) {
if (i % 2) {
ans -= f[i];
ans %= 1000000007;
} else {
ans += f[i];
ans %= 1000000007;
}
}
printf("%I64d\n", (ans % 1000000007 + 1000000007) % 1000000007);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int m = 20;
const int mod = 1e9 + 7;
const int maxn = (1 << m);
long long d[maxn][m + 1];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, a;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
d[a][0]++;
d[a][0] *= 2;
d[a][0]--;
d[a][0] %= mod;
}
for (int mask = (1 << m) - 1; mask >= 0; mask--) {
for (int i = 1; i <= m; i++) {
if (!((1 << (i - 1)) & mask))
d[mask][i] =
(d[mask][i - 1] + 1) * (d[mask ^ (1 << (i - 1))][i - 1] + 1) - 1;
else
d[mask][i] += d[mask][i - 1];
d[mask][i] %= mod;
}
}
long long ans = 0;
for (int i = 0; i < (1 << m); i++) {
if (__builtin_popcount(i) % 2 == 0)
ans += d[i][m];
else
ans -= d[i][m];
ans += mod;
ans %= mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 2e6 + 9;
int n, f[N], a[N];
long long qpow(long long x, long long y) {
long long t = 1;
while (y) {
if (y & 1) (t *= x) %= mod;
y >>= 1, (x *= x) %= mod;
}
return t;
}
long long g[N], t[N];
int lowbit(int x) { return x & (-x); }
int main() {
scanf("%d", &n);
int M = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
f[a[i]]++;
M = max(M, a[i]);
}
for (int i = 0; i < 20; i++)
for (int j = M - (1 << i); j >= 0; j--)
if (!(j & (1 << i))) f[j] += f[j | (1 << i)];
for (int i = (1 << 20) - 1; i >= 0; i--)
g[i] = ((qpow(2, f[i]) - 1) % mod + mod) % mod;
t[0] = 0;
for (int i = 1; i < (1 << 20); i++) t[i] = t[i - lowbit(i)] + 1;
long long ans = qpow(2, n);
for (int i = 1; i < (1 << 20); i++) {
long long k = (t[i] % 2 == 1) ? (-1) : 1;
ans = ((ans + k * g[i] % mod) % mod + mod) % mod;
}
printf("%lld\n", ans - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, x, ans, i, j, md, f[1000002], d[1000002];
int main() {
cin >> n;
md = 1000000007;
m = 1000000;
f[0] = 1;
for (i = 1; i <= m; i++) f[i] = (f[i - 1] * 2) % md;
for (i = 1; i <= n; i++) {
cin >> x;
d[x]++;
}
for (i = 20; i >= 0; i--)
for (j = m; j >= 0; j--)
if (j & (1 << (i))) d[j ^ (1 << i)] += d[j];
for (int j = 0; j <= m; j++)
if (d[j]) {
if (__builtin_popcount(j) % 2)
ans = (ans - f[d[j]] + 1 + md) % md;
else
ans = (ans + f[d[j]] - 1 + md) % md;
}
cout << (ans + md) % md << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
_main();
}
int mod = 1000000007;
int add(int x, int y) { return (x += y) >= mod ? x - mod : x; }
template <class... T>
int add(int x, T... y) {
return add(x, add(y...));
}
int mul(int x, int y) { return 1LL * x * y % mod; }
template <class... T>
int mul(int x, T... y) {
return mul(x, mul(y...));
}
int sub(int x, int y) { return add(x, mod - y); }
int modpow(int a, long long b) {
int ret = 1;
while (b > 0) {
if (b & 1) ret = 1LL * ret * a % mod;
a = 1LL * a * a % mod;
b >>= 1;
}
return ret;
}
int modinv(int a) { return modpow(a, mod - 2); }
int fac[201010], ifac[201010];
void initfac() {
fac[0] = ifac[0] = 1;
for (int i = 1; i < 201010; i++) fac[i] = 1LL * i * fac[i - 1] % mod;
for (int i = 1; i < 201010; i++) ifac[i] = modinv(fac[i]);
}
int aPb(int a, int b) {
if (b < 0 || a < b) return 0;
return mul(fac[a], ifac[a - b]);
}
int aCb(int a, int b) {
if (b < 0 || a < b) return 0;
return mul(fac[a], ifac[a - b], ifac[b]);
}
int nHk(int n, int k) {
if (n == 0 && k == 0) return 1;
if (n <= 0 || k < 0) return 0;
return aCb(n + k - 1, k);
}
int N;
int A[1 << 20];
void _main() {
cin >> N;
for (int i = 0; i < N; i++) {
int x;
cin >> x;
A[x]++;
}
for (int i = 0; i < 20; i++)
for (int j = 0; j < 1 << 20; j++)
if (!(j & (1 << i))) A[j] = add(A[j], A[j | (1 << i)]);
int ans = 0;
for (int ma = 0; ma < 1 << 20; ma++) {
if (__builtin_popcount(ma) % 2)
ans = sub(ans, modpow(2, A[ma]));
else
ans = add(ans, modpow(2, A[ma]));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &first) {
int f = 1;
first = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
first = (first << 3) + (first << 1) + c - '0';
c = getchar();
}
first *= f;
return;
}
void write(register int first) {
if (first < 0) {
first = ~first + 1;
putchar('-');
}
if (first > 9) write(first / 10);
putchar(first % 10 + '0');
return;
}
int n;
long long f[(1 << 20)], ans;
long long power(long long first, long long second) {
long long ret = 1;
for (; second; second >>= 1, first = first * first % (int)(1e9 + 7))
ret = ret * (second & 1 ? first : 1) % (int)(1e9 + 7);
return ret;
}
int count(int first) {
int ret = 0;
for (; first; first >>= 1) ret += first & 1;
return ret;
}
int main() {
read(n);
for (register int(i) = (1); (i) <= (n); i++) {
int first;
read(first);
f[first]++;
}
for (register int(i) = (0); (i) <= (19); i++)
for (register int(j) = ((1 << 20) - 1); (j) >= (0); j--)
if (!(j & (1 << i))) (f[j] += f[j | (1 << i)]) %= (int)(1e9 + 7);
for (register int(i) = (0); (i) <= ((1 << 20) - 1); i++)
(ans += (power(2, f[i]) - 1) * (count(i) & 1 ? -1 : 1)) %= (int)(1e9 + 7);
write((ans + (int)(1e9 + 7)) % (int)(1e9 + 7));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 21) + 5;
const int mod = 1e9 + 7;
int dp[22][maxn];
int ted[maxn], n;
long long t2[maxn], ans;
int main() {
t2[0] = 1;
for (int i = 1; i < (1 << 21); i++) t2[i] = (t2[i - 1] * 2) % mod;
cin >> n;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
ted[a]++;
}
for (int i = 0; i < (1 << 21); i++) dp[0][i] = ted[i];
for (long long k = 1; k <= 20; k++)
for (long long i = 0; i < (1 << 21); i++) {
if ((i >> (k - 1)) & 1)
dp[k][i] = dp[k - 1][i];
else
dp[k][i] = dp[k - 1][i] + dp[k - 1][i + (1 << (k - 1))];
}
for (int i = 0; i < (1 << 21); i++) {
if ((__builtin_popcount(i)) % 2)
ans = (ans - t2[dp[20][i]]) % mod;
else
ans = (ans + t2[dp[20][i]]) % mod;
}
ans = (ans + mod) % mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e6 + 9, K = 20, M = 1 << K, mod = (int)1e9 + 7;
int n, a[N], f[M], pw[N] = {1};
short builtin_popcount(int x) {
short ans = 0;
while (x) {
ans += (x & 1);
x >>= 1;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 1, a; i <= n; ++i) {
cin >> a;
++f[a];
pw[i] = pw[i - 1] << 1;
if (pw[i] > mod) pw[i] -= mod;
}
for (int i = 0; i < K; ++i)
for (int mask = 0; mask < M; ++mask)
if (!(mask & (1 << i))) f[mask] += f[mask ^ (1 << i)];
long long ans = 0;
for (int mask = 0; mask < M; ++mask) {
if (builtin_popcount(mask) & 1)
ans -= pw[f[mask]];
else
ans += pw[f[mask]];
}
ans %= mod;
if (ans < 0) ans += mod;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[(1 << 20)];
int pwr[1000005];
int mod_mul(long long a, long long b) { return (a * b) % 1000000007; }
int mod_plus(int a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
return a;
}
int mod_min(int a, int b) {
a -= b;
if (a < 0) a += 1000000007;
return a;
}
void go(int st, int total) {
if (!total) return;
for (int i = 0; i < total; i++) cnt[st + i] += cnt[st + i + total];
go(st, total / 2);
go(st + total, total / 2);
}
int main() {
int i, n, j;
pwr[0] = 1;
for (i = 1; i < 1000005; i++) pwr[i] = mod_mul(pwr[i - 1], 2);
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &j);
cnt[j]++;
}
go(0, (1 << 20) / 2);
int ans = 0;
for (i = 0; i < (1 << 20); i++) {
if (__builtin_popcount(i) % 2)
ans = mod_min(ans, pwr[cnt[i]]);
else
ans = mod_plus(ans, pwr[cnt[i]]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1 << 20;
int n, a[maxn], f[21][maxn], p2[maxn], ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
f[0][a[i]]++;
}
for (int i = 1; i <= 20; i++) {
for (int j = 0; j < (1 << 20); j++) {
if ((j >> (i - 1)) & 1) {
f[i][j] = f[i - 1][j];
} else {
f[i][j] = f[i - 1][j] + f[i - 1][j + (1 << (i - 1))];
f[i][j] -= (f[i][j] >= mod) ? mod : 0;
}
}
}
p2[0] = 1;
for (int i = 1; i <= n; i++)
p2[i] = p2[i - 1] + p2[i - 1], p2[i] -= (p2[i] >= mod) ? mod : 0;
for (int i = 0; i < (1 << 20); i++)
if (__builtin_popcount(i) & 1) {
ans -= p2[f[20][i]];
if (ans < 0) ans += mod;
} else {
ans += p2[f[20][i]];
ans -= (ans >= mod) ? mod : 0;
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1200 * 1000 + 10, mod = 1000000007, maxk = 21;
int tvn[maxn], n, a, t[maxn], dp[maxn][maxk];
long long ans;
bool b[maxk];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a);
t[a]++;
}
for (int i = 1; i < maxn; i++) tvn[i] = (((2 * tvn[i - 1]) % mod) + 1) % mod;
for (int i = (1 << (maxk - 1)) - 1; i >= 1; i--) {
a = i;
for (int j = maxk - 1; j >= 1; j--) {
b[j] = a & 1;
a >>= 1;
}
dp[i][0] = t[i];
for (int j = 1; j < maxk; j++) {
dp[i][j] = dp[i][j - 1];
if (!b[j]) dp[i][j] += dp[i ^ (1 << (maxk - j - 1))][j - 1];
}
if (__builtin_popcount(i) & 1)
ans = (ans + tvn[dp[i][maxk - 1]]) % mod;
else
ans = (ans + mod - tvn[dp[i][maxk - 1]]) % mod;
}
printf("%I64d", (tvn[n] + mod - ans) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 1e6;
int cnt[N + 10];
long long two[N + 10];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
cnt[a]++;
}
for (int j = 19; j >= 0; j--) {
for (int i = 1; i <= N; i++) {
if ((i >> j) & 1) {
cnt[i - (1 << j)] += cnt[i];
}
}
}
two[0] = 1;
for (int i = 1; i <= N; i++) {
two[i] = (two[i - 1] * 2) % mod;
}
for (int i = 0; i <= N; i++) {
two[i] = (two[i] - 1 + mod) % mod;
}
long long ans = two[n];
for (int i = 1; i <= N; i++) {
int one = __builtin_popcount(i);
if (one & 1) {
ans = (ans - two[cnt[i]] + mod) % mod;
} else {
ans = (ans + two[cnt[i]]) % mod;
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXLA = 20, MOD = 1e9 + 7;
int n, x, f[(1 << MAXLA)], ans;
int powmod(int b, int e) {
if (!e) return 1;
if (e & 1) return (1LL * b * powmod(b, e - 1)) % MOD;
int aux = powmod(b, e >> 1);
return (1LL * aux * aux) % MOD;
}
int main() {
for (scanf("%d", &n); n--;) scanf("%d", &x), f[x]++;
for (int i = 0, mask; i < MAXLA; ++i)
for (mask = 0; mask < (1 << MAXLA); ++mask)
if (mask & (1 << i)) f[mask ^ (1 << i)] += f[mask];
for (int mask = 0; mask < (1 << MAXLA); ++mask)
ans =
(0LL + ans +
1LL * powmod(MOD - 1, __builtin_popcount(mask)) * powmod(2, f[mask])) %
MOD;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
const int N = 3e6 + 5;
int bit[N], pw[N], f[N];
char IN[1000000], *SS = IN, *TT = IN;
inline int read() {
int now = 0;
register char c =
(SS == TT && (TT = (SS = IN) + fread(IN, 1, 1000000, stdin), SS == TT)
? EOF
: *SS++);
for (; !isdigit(c);
c = (SS == TT &&
(TT = (SS = IN) + fread(IN, 1, 1000000, stdin), SS == TT)
? EOF
: *SS++))
;
for (; isdigit(c);
now = now * 10 + c - '0',
c = (SS == TT &&
(TT = (SS = IN) + fread(IN, 1, 1000000, 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;
int N;
long long a[1000000];
long long dp[1 << 22];
const int MOD = 1e9 + 7;
int main() {
cin.sync_with_stdio(false);
while (cin >> N) {
for (int i = 0; i < N; ++i) cin >> a[i];
fill(dp, dp + (1 << 20), 1);
for (int i = 0; i < N; ++i) dp[a[i]] = (dp[a[i]] * 2) % MOD;
for (int i = 0; i < 20; ++i) {
for (int j = 0; j < (1 << 20); ++j) {
if ((j >> i) & 1) continue;
dp[j] = (dp[j] * dp[j | (1 << i)]) % MOD;
}
}
long long ans = 0;
for (int i = 0; i < (1 << 20); ++i) {
int cnt = __builtin_popcount(i);
if (cnt % 2 == 0)
ans = (ans + dp[i]) % MOD;
else
ans = (ans - dp[i] + MOD) % MOD;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
long long mpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n /= 2;
}
return res;
}
long long inv(long long x) { return mpow(x, mod - 2); }
int main() {
vector<long long> fac(10000, 1);
vector<long long> invfac(10000, 1);
for (int i = 2; i < fac.size(); ++i) {
fac[i] = fac[i - 1] * i % mod;
invfac[i] = inv(fac[i]);
}
vector<long long> pw2(1000001, 1);
for (int i = 1; i < pw2.size(); ++i) pw2[i] = pw2[i - 1] * 2 % mod;
int n;
cin >> n;
vector<int> a(n);
vector<vector<long long> > v(1000001, vector<long long>(21));
for (int i = 0; i < a.size(); ++i) {
scanf("%d", &a[i]);
++v[a[i]][0];
}
long long res = 0;
for (int i = v.size() - 1; i >= 0; --i) {
long long tot = v[i][0];
int maxind = 0;
for (int h = 1; h < v[i].size(); ++h)
if (v[i][h]) {
v[i][h] %= mod;
tot = (tot + v[i][h] * invfac[h]) % mod;
maxind = h;
}
maxind = min(maxind, (int)v[i].size() - 2);
int cnt = 0;
for (int b = 0; b < 20; ++b)
if (i & (1 << b)) {
++cnt;
int j = (i ^ (1 << b));
for (int h = 0; h <= maxind; ++h) v[j][h + 1] += v[i][h];
}
res = (res + ((cnt % 2) ? -1 : 1) * (pw2[tot] - 1)) % mod;
}
cout << (res % mod + mod) % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 22;
const int mod = 1e9 + 7;
int dp[1 << N];
int pw[1 << N];
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int cur;
cin >> cur;
dp[cur]++;
}
pw[0] = 1;
for (int i = 1; i < (1 << N); i++) pw[i] = (long long)pw[i - 1] * 2 % mod;
for (int j = 0; j < N; j++)
for (int i = 0; i < (1 << N); i++)
if (i & (1 << j)) dp[i ^ (1 << j)] += dp[i];
int ans = 0;
for (int i = 0; i < (1 << N); i++) {
if (__builtin_popcount(i) & 1)
ans = (ans + mod - pw[dp[i]]) % mod;
else
ans = (ans + pw[dp[i]]) % mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 20;
const long long K = 21;
const long long maxk = 1e6 + 6;
const long long maxn = 1e6;
const long long mod = 1e9 + 7;
const long long p2N = ((1 << N) - 1);
long long dp[p2N + 1], n, arr[maxk], p2[maxk], ans, tmp;
long long add(long long a, long long b, long long md) {
long long ret = a + b;
if (ret >= md) ret -= md;
return ret;
}
long long dif(long long a, long long b, long long md) {
long long ret = a - b;
if (ret < 0) ret += md;
return ret;
}
int main() {
for (int i = 0; i < maxk; i++) p2[i] = (i == 0) ? 1 : (p2[i - 1] * 2) % mod;
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &arr[i]);
dp[p2N ^ arr[i]]++;
}
for (int i = 0; i < N; i++)
for (int j = 0; j <= p2N; j++)
if (!(j & (1 << i))) dp[j + (1 << i)] += dp[j];
for (int i = 0; i <= p2N; i++) {
if (__builtin_popcount(i) % 2 & 1)
ans = dif(ans, p2[dp[i]], mod);
else
ans = add(ans, p2[dp[i]], mod);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 1e9 + 7;
const long long MAX_N = 1 << 20;
long long C[MAX_N];
long long A[MAX_N];
long long n;
long long P[MAX_N];
long long popcount(long long x) {
long long ret = 0;
while (x > 0) {
ret++;
x -= ((x) & (-(x)));
}
return ret;
}
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> A[i];
C[A[i]]++;
}
P[0] = 1;
for (long long i = 1; i < (1 << 20); i++) P[i] = P[i - 1] * 2 % Mod;
for (long long j = 0; j < 20; j++) {
for (long long i = (1 << 20) - 1; i >= 0; i--) {
if (i >> j & 1) C[i ^ (1 << j)] += C[i];
assert(C[i] >= 0 && C[i] <= n);
}
}
long long ans = 0;
for (long long i = 0; i < (1 << 20); i++) {
if (popcount(i) % 2)
ans -= P[C[i]];
else
ans += P[C[i]];
ans = (ans + Mod) % Mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
long long read() {
long long x = 0, f = 1;
char ch;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') {
x = x * 10 + ch - '0';
ch = getchar();
}
return f * x;
}
long long count(long long x) {
long long ans = 0;
for (; x; x -= (x & -x)) ans++;
return ans;
}
long long fu(long long x) { return x & 1 ? -1 : 1; }
long long g[1050000], n, a, po[1050000];
long long ans;
int main() {
n = read();
po[0] = 1;
for (long long i = 1; i <= n; i++) {
a = read();
g[a]++;
}
for (long long i = 0; i <= 20; i++) {
for (long long j = 0; j <= 1000000; j++) {
if (j & (1 << i)) g[j ^ (1 << i)] += g[j];
}
}
for (long long i = 1; i <= 1000000; i++) po[i] = po[i - 1] * 2 % 1000000007;
for (long long i = 0; i <= 1000000; i++) {
ans = ((ans + fu(count(i)) * (po[g[i]] - 1)) % 1000000007 + 1000000007) %
1000000007;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e6 + 3, mod = 1e9 + 7;
long long n, ans = 0;
long long v[maxn];
long long dp[(1 << 20) + 1];
long long binexp(long long b, long long e) {
long long x = 1;
long long y = b;
while (e) {
if (e & 1) x = (x * y) % mod;
y = (y * y) % mod;
e >>= 1;
}
return x;
}
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &v[i]);
dp[(1 << 20) - v[i] - 1]++;
}
for (long long i = 0; i <= 20; i++)
for (long long j = 0; j < (1 << 20); j++)
if (j & (1 << i)) {
dp[j] += dp[j ^ (1 << i)];
if (dp[j] >= mod) dp[j] -= mod;
}
for (long long i = 0; i < (1 << 20); i++) {
long long bits = 20 - __builtin_popcount(i);
if (bits & 1) {
ans -= binexp(2, dp[i]);
if (ans < 0) ans += mod;
} else {
ans += binexp(2, dp[i]);
if (ans >= mod) ans -= mod;
}
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20;
const int M = N + 100;
const int P = 1000000007;
int inc(int x, int y) {
int ans = x + y;
if (ans >= P) ans -= P;
return ans;
}
int Dec(int x, int y) {
int ans = x - y;
if (ans < 0) ans += P;
return ans;
}
long long val[M];
void init_(int l, int r) {
if (l == r - 1) return;
int m = (r + l) >> 1;
int d = (r - l) >> 1;
init_(l, m);
init_(m, r);
for (int i = 0; i <= d - 1; i++) {
(val[l + i] *= val[m + i]) %= P;
}
}
void solve(int l, int r) {
if (l == r - 1) return;
int m = (r + l) >> 1;
int d = (r - l) >> 1;
solve(l, m);
solve(m, r);
for (int i = 0; i <= d - 1; i++) {
val[l + i] = Dec(val[l + i], val[m + i]);
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i <= N - 1; i++) val[i] = 1;
for (int i = 1; i <= n; i++) {
int v;
scanf("%d", &v);
val[v] = inc(val[v], val[v]);
}
init_(0, N);
solve(0, N);
cout << val[0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int ret = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -f;
ch = getchar();
}
while (ch <= '9' && ch >= '0') ret = ret * 10 + ch - '0', ch = getchar();
return ret * f;
}
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++) dp[read()]++;
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 MAXN = 1100000;
const int MOD = 1e9 + 7;
int val[MAXN];
int dp[21][(1 << 21)];
int GetLen(int x) {
int rnt = 0;
for (int i = 0; i < 20; i++)
if ((1 << i) & x) rnt++;
return rnt;
}
long long Pow(int x) {
long long rnt = 1, mulv = 2;
while (x) {
if (x & 1) rnt *= mulv;
rnt %= MOD;
mulv *= mulv;
mulv %= MOD;
x >>= 1;
}
return rnt;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &val[i]);
dp[0][val[i]]++;
}
for (register int i = 0; i < 20; ++i) {
for (register int j = 0; j < (1 << 20); ++j) {
if ((1 << i) & j)
dp[i + 1][j] = dp[i][j];
else
dp[i + 1][j] = (dp[i][j] + dp[i][j + (1 << i)]) % MOD;
}
}
long long ans = 0;
for (register int i = 0; i < (1 << 20); ++i) {
int len = GetLen(i);
ans += Pow(dp[20][i]) * (len & 1 == 1 ? -1 : 1);
ans = (ans % MOD + MOD) % MOD;
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 1000010;
long long n, m, k, u, v, x, y, t, a, b, ans;
int A[MAXN];
long long cnt[MAXN];
long long tav[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (int i = 1; i < MAXN; i++) tav[i] = (tav[i - 1] * 2 + 1) % mod;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
cnt[A[i]]++;
}
for (int j = 0; j < 20; j++)
for (int i = 0; i < MAXN; i++)
if (i & (1 << j)) cnt[i ^ (1 << j)] += cnt[i];
for (int i = 0; i < MAXN; i++) {
if (__builtin_popcount(i) & 1)
ans = (ans - tav[cnt[i]]) % mod;
else
ans = (ans + tav[cnt[i]]) % mod;
}
cout << (ans + mod) % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) {
res = (res * x) % p;
}
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long modInverse(long long a, long long p) { return power(a, p - 2, p); }
long long gcd(long long x, long long y) {
if (x == 0 || y == 0) {
return max(y, x);
}
return gcd(y % x, x);
}
long long a[1 << 20];
long long b[1 << 20];
long long powerb[1 << 20];
long long dp[1 << 20][21];
long long cnt[1 << 20];
int main() {
long long n;
scanf("%lld", &n);
long long maxi = (1 << 20) - 1;
for (long long i = 0; i < n; i++) {
long long x;
scanf("%lld", &x);
a[maxi - x]++;
}
for (int i = 0; i < (1 << 20); ++i) b[i] = a[i];
for (int i = 0; i < 20; ++i)
for (int mask = 0; mask < (1 << 20); ++mask) {
if (mask & (1 << i)) b[mask] += b[mask ^ (1 << i)];
}
for (long long i = 0; i < (1 << 20); i++) {
powerb[i] = power(2LL, b[i], 1000000007);
}
for (long long mask = 0; mask < (1 << 20); mask++) {
dp[mask][0] = 0;
for (long long i = 1; i <= 20; i++) {
if (mask & (1 << (i - 1)))
dp[mask][i] = dp[mask][i - 1] + dp[mask ^ (1 << (i - 1))][i - 1];
else
dp[mask][i] = dp[mask][i - 1];
dp[mask][i] %= 1000000007;
}
cnt[mask] = powerb[mask] - dp[mask][20];
cnt[mask] += 1000000007;
cnt[mask] %= 1000000007;
dp[mask][0] = cnt[mask];
for (long long i = 1; i <= 20; i++) {
if (mask & (1 << (i - 1)))
dp[mask][i] = dp[mask][i - 1] + dp[mask ^ (1 << (i - 1))][i - 1];
else
dp[mask][i] = dp[mask][i - 1];
dp[mask][i] %= 1000000007;
}
}
cout << cnt[maxi] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7, limit = (1 << 21);
const int maxn = 2300000;
int n, a[maxn], f[21][maxn], g[maxn];
long long ans;
long long qpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
long long get(long long x) {
long long res = 0;
for (long long i = 0; i < 21; i++)
if (x >> i & 1) res++;
return res;
}
int main() {
scanf("%d", &n);
for (long long i = 1; i <= n; i++) {
long long t;
scanf("%lld", &t);
f[0][t]++;
}
for (long long i = 1; i <= 21; i++)
for (long long j = 0; j <= limit; j++) {
f[i][j] = f[i - 1][j];
if (!(j >> (i - 1) & 1)) (f[i][j] += f[i - 1][j | (1 << (i - 1))]) %= mod;
}
for (long long i = 0; i <= limit; i++) g[i] = f[21][i];
for (long long i = 0; i < limit; i++) {
long long temp = qpow(-1, get(i));
temp = temp * (qpow(2, g[i]) - 1 + mod) % mod;
ans = (ans + temp + mod) % mod;
}
printf("%lld\n", (ans + mod) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long a, long long b, long long m) {
if (b == 0LL) return 1LL;
if (b == 1LL) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1LL) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
const long long N = (1 << 20) + 5, L = 20;
const long long M = 1000000007;
long long a[N];
long long pot[(1 << 20) + 10];
long long F[(1 << 20) + 100];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
F[a[i]]++;
}
long long full = (1LL << 20) - 1;
for (long long i = 0; i < L; i++) {
for (long long msk = 0; msk < (1 << 20); msk++) {
if (msk & (1 << i)) F[msk ^ (1 << i)] += F[msk];
}
}
pot[0] = 1;
for (long long i = 1; i <= N; i++) pot[i] = (2LL * pot[i - 1]) % M;
long long res = 0;
for (long long i = 0; i < (1 << 20); i++) {
if (__builtin_popcount(i) & 1) {
res = (res - pot[F[i]]) % M;
} else
res = (res + pot[F[i]]) % M;
}
res %= M;
if (res < 0) res += M;
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18, MOD = 1e9 + 7, MOD2 = 1e6 + 3;
const int M = 1e6;
int cnt[1 << 20], cnt_r[1 << 20], n, d[1 << 20];
int bin[1000000];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
d[a]++;
}
bin[0] = 1;
for (int i = 1; i <= n; i++) {
bin[i] = bin[i - 1] + bin[i - 1];
if (bin[i] >= MOD) bin[i] -= MOD;
}
int m = 20;
for (int i = 0; i < (1 << m); i++) {
if (!d[i]) continue;
for (int j = i; j & ((1 << 10) - 1); j = (i & (j - 1))) {
cnt_r[j] += d[i];
}
cnt_r[(i >> 10) << 10] += d[i];
}
for (int i = 0; i < (1 << 20); i++) {
if (!cnt_r[i]) continue;
int hi = (i >> 10), lo = (i & ((1 << 10) - 1));
for (int j = hi; j; j = (hi & (j - 1))) cnt[(j << 10) + lo] += cnt_r[i];
cnt[lo] += cnt_r[i];
}
long long ans = bin[n] - 1;
for (int i = 1; i < (1 << 20); i++) {
if (!cnt[i]) continue;
if (__builtin_popcount(i) & 1)
ans += MOD - bin[cnt[i]] + 1;
else
ans += bin[cnt[i]] - 1;
if (ans >= MOD) ans -= MOD;
}
cout << ans;
}
|
#include <bits/stdc++.h>
int a[1000100];
const int mod = 1000000007;
int b[1 << 20];
int p[1000100];
int main() {
int n;
scanf("%d", &n);
int C = (1 << 20) - 1;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
b[a[i]]++;
}
for (int i = 0; i < 20; i++) {
for (int j = 0; j < 1 << 20; j++) {
if ((j >> i & 1) == 0) {
b[j] += b[j | (1 << i)];
}
}
}
int ans = 0;
p[0] = 1;
for (int i = 0; i < n; i++) {
p[i + 1] = (p[i] << 1) % mod;
}
for (int i = 0; i < 1 << 20; i++) {
int t = p[b[i]];
for (int j = 0; j < 20; j++) {
if (i >> j & 1) t = -t;
}
if (t < 0) {
t += mod;
}
ans += t;
if (ans >= mod) {
ans -= mod;
}
}
printf("%d\n", ans);
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;
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;
const double eps = 1e-9;
const int maxmask = 1000010;
const int mod = 1000000007;
int cnt[maxmask], pw[maxmask];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
int ai;
scanf("%d", &ai);
cnt[ai]++;
}
pw[0] = 1;
for (int i = 1; i <= n; ++i) {
pw[i] = (pw[i - 1] * 2) % mod;
}
for (int bit = 1; bit < maxmask; bit <<= 1) {
for (int mask = 0; mask < maxmask; ++mask) {
if (mask & bit) cnt[mask ^ bit] += cnt[mask];
}
}
int res = pw[n] - 1;
for (int i = 1; i < maxmask; ++i) {
int bits = 0;
for (int bit = 1; bit <= i; bit <<= 1) {
if (i & bit) ++bits;
}
int add = pw[cnt[i]] - 1;
if (bits & 1)
res -= add;
else
res += add;
res = res % mod;
}
res = (res + mod) % mod;
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int lg = 20;
const int maxn = 2e6 + 100;
const int mod = 1e9 + 7;
const int inf = 1e9;
int n, a, c[maxn][2], dp[maxn][2], p[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
p[0] = 1;
for (int i = 1; i < maxn; i++) {
p[i] = (p[i - 1] * 2) % mod;
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
c[a][0]++;
}
for (int j = 1; j <= lg; j++) {
for (int i = 0; i < (1ll << lg); i++) {
c[i][j % 2] = c[i][1 - j % 2];
if (!((i >> (j - 1)) & 1))
c[i][j % 2] += c[i + (1ll << (j - 1))][1 - j % 2];
c[i][j % 2] %= mod;
}
}
for (int i = 0; i < (1ll << lg); i++) {
dp[i][0] = p[c[i][lg % 2]] - 1;
if (__builtin_popcount(i) % 2) dp[i][0] *= -1;
}
for (int j = 1; j <= lg; j++) {
for (int i = 0; i < (1ll << lg); i++) {
dp[i][j % 2] = dp[i][1 - j % 2];
if (!((i >> (j - 1)) & 1))
dp[i][j % 2] += dp[i + (1ll << (j - 1))][1 - j % 2];
dp[i][j % 2] %= mod;
}
}
cout << (dp[0][lg % 2] + mod) % mod;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const long long mo = 1e9 + 7;
long long f[N + 1], g[N + 1], b[N + 1], ans;
int n, a[N], tot;
int main() {
scanf("%d", &n);
for (int(i) = (1); (i) <= (n); (i)++) scanf("%d", &a[i]), f[a[i]]++;
b[0] = 1;
for (int(i) = (1); (i) <= (N); (i)++) b[i] = b[i - 1] * 2ll % mo;
for (int(j) = (0); (j) <= (20); (j)++) {
for (int(i) = (0); (i) <= (N); (i)++)
if (i & b[j]) f[i ^ b[j]] += f[i];
}
for (int(i) = (0); (i) <= (N); (i)++) {
tot = 0;
for (int(j) = (0); (j) <= (20); (j)++)
if (i & b[j]) tot++;
g[tot] = (g[tot] + b[f[i]] - 1) % mo;
}
for (int(i) = (0); (i) <= (20); (i)++) {
if (i % 2 == 0)
ans = (ans + g[i]) % mo;
else
ans = (ans - g[i]) % mo;
}
printf("%lld", (ans % mo + mo) % mo);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long u, long long v) {
while (v != 0) {
long long r = u % v;
u = v;
v = r;
}
return u;
}
const int MOD = 1000000007;
int n;
int a[1000000];
int p2[1000000];
int cnt[1 << 20];
int h[1 << 20];
void calc(int k, int y) {
if (k == 0) {
h[y] = cnt[y];
return;
}
calc(k - 1, y);
calc(k - 1, y + (1 << (k - 1)));
for (int i = (0); i < (1 << (k - 1)); ++i)
h[y + i] += h[y + i + (1 << (k - 1))];
}
void run() {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) scanf("%d", &a[i]);
memset(cnt, 0, sizeof(cnt));
for (int i = (0); i < (n); ++i) ++cnt[a[i]];
p2[0] = 1;
for (int i = (1); i <= (n); ++i) {
p2[i] = p2[i - 1] + p2[i - 1];
if (p2[i] >= MOD) p2[i] -= MOD;
}
calc(20, 0);
int ret = 0;
for (int i = (0); i < (1 << 20); ++i) {
int g = h[i];
int f = p2[g] - 1;
if (f < 0) f += MOD;
int sign = +1;
for (int j = (0); j < (20); ++j)
if (i & (1 << j)) sign = -sign;
if (sign == +1) {
ret = ret + f;
if (ret >= MOD) ret -= MOD;
} else {
ret = ret - f;
if (ret < 0) ret += MOD;
}
}
printf("%d\n", ret);
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
using namespace std;
long long mod = (1000000007LL);
inline long long Mod(long long a, long long b) { return (a % b); }
inline long long poww(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
long long gcd(long long a, long long b) {
while (b) {
a %= b, swap(a, b);
}
return a;
}
void read(vector<int> &w, int n) {
w.resize(n);
for (int i = 0; i < n; i++) cin >> w[i];
}
void print(vector<int> &w) {
for (int i = 0; i < (int)(w).size(); i++) {
if (i == (int)(w).size() - 1)
cout << w[i] << "\n";
else
cout << w[i] << " ";
}
}
int prodmod(vector<int> w);
int summod(vector<int> w);
int n, m, q, k, v[1000050], ans;
pair<int, int> w[1000050];
string second;
int qtd[1000050], ini[1000050];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
vector<long long> pot(1000050);
pot[0] = 1;
for (int i = 1; i < 1000050; i++) pot[i] = (2LL * pot[i - 1]) % mod;
for (int i = 1; i <= n; i++) {
cin >> v[i];
qtd[v[i]]++;
}
for (int i = 0; i < 20; i++) {
for (int mask = 0; mask < 1000050; mask++) {
if ((mask & (1 << i)) or (mask ^ (1 << i)) >= 1000050) continue;
qtd[mask] += qtd[mask ^ (1 << i)];
}
}
long long ans = 0;
for (int mask = 0; mask < 1000050; mask++) {
qtd[mask] = pot[qtd[mask]] - 1;
int tam = __builtin_popcount(mask) % 2;
ans += (tam ? -1LL : 1LL) * qtd[mask];
ans %= mod;
}
if (ans < 0) ans += mod;
cout << ans % mod << "\n";
}
int summod(vector<int> w) {
int curr = 0;
for (int i = 0; i < (int)(w).size(); i++) {
curr = (curr + w[i]) % mod;
if (curr < 0) curr += mod;
}
return curr;
}
int prodmod(vector<int> w) {
int curr = 1;
for (int i = 0; i < (int)(w).size(); i++) {
if (w[i] >= mod) w[i] %= mod;
curr = (curr * w[i]) % mod;
if (curr < 0) curr += mod;
}
return curr;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxv = 1e5 + 30;
const long long mod = 1000000007;
int N;
int a[1 << 20];
int dp[22][1 << 20];
int fpow(int x, long long p) {
long long ans = 1;
while (p > 0) {
if (p & 1) ans = (x * ans) % mod;
x = (x * x) % mod;
p >>= 1;
}
return (int)ans;
}
int q_pow(int x, int n, long long mod) {
long long ans = 1, xx = x;
for (; n > 0; n >>= 1) {
if (n & 1) ans = ans * xx % mod;
xx = xx * xx % mod;
}
return (int)ans;
}
void add(int &a, int b) {
a += b;
if (a < 0) a += mod;
if (a >= mod) a -= mod;
}
int main() {
cin >> N;
for (int i = 0; i < N; i++) scanf("%d", &a[i]);
sort(a, a + N);
for (int i = 0; i < N; i++) {
if (a[i] & 1)
dp[0][a[i]]++, dp[0][a[i] - 1]++;
else
dp[0][a[i]]++;
}
for (int i = 0; i < 19; i++) {
for (int j = 0; j < (1 << 20); j++) {
int t = 1 << (1 + i);
if (j & t)
dp[i + 1][j] += dp[i][j], dp[i + 1][j - t] += dp[i][j];
else
dp[i + 1][j] += dp[i][j];
}
}
int ans = 0;
for (int j = 0; j < (1 << 20); j++) {
int t = 1;
for (int i = 0; i < 20; i++)
if ((1 << i) & j) t = -t;
int tt = q_pow(2, dp[19][j], mod);
tt--;
if (tt < 0) tt += mod;
ans += t * tt;
if (ans >= mod) ans -= mod;
if (ans < 0) ans += mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
long long memo[(1 << 21)];
long long modexp(long long a, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = ((res % 1000000007) * (a % 1000000007)) % 1000000007;
a = ((a % 1000000007) * (a % 1000000007)) % 1000000007;
n >>= 1;
}
return res;
}
int main(void) {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
int n;
std::cin >> n;
for (int i = 0; i < n; i++) {
int t;
std::cin >> t;
memo[t]++;
}
for (int p = 0; p < 21; p++) {
for (int mask = ((1 << 21) - 1); mask >= 0; mask--) {
if (!(mask & (1 << p))) memo[mask] += memo[mask ^ (1 << p)];
}
}
long long ans = 0;
for (int mask = 0; mask < (1 << 21); mask++) {
int z = __builtin_popcount(mask);
if (z & 1)
ans = ((ans % 1000000007) - ((modexp(2, memo[mask]) - 1) % 1000000007) +
1000000007) %
1000000007;
else
ans = ((ans % 1000000007) + ((modexp(2, memo[mask]) - 1) % 1000000007)) %
1000000007;
}
std::cout << ans << "\n";
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;
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 long long INF = 1LL << 60;
const double INFF = 1e100;
const double eps = 1e-8;
const int mod = 1000000007;
const int NN = 100005;
const int MM = 1000010;
int dp[20][1 << 20];
int a[1 << 20];
int q_pow(int x, int n, long long mod) {
long long ans = 1, xx = x;
for (; n > 0; n >>= 1) {
if (n & 1) ans = ans * xx % mod;
xx = xx * xx % mod;
}
return (int)ans;
}
int main() {
int n, i, j, mask = 1 << 20;
int ans, t, tt;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(dp, 0, sizeof(dp));
for (i = 1; i <= n; i++) {
if (a[i] & 1) {
dp[0][a[i]]++;
dp[0][a[i] ^ 1]++;
} else {
dp[0][a[i]]++;
}
}
for (i = 0; i < 19; i++)
for (j = 0; j < mask; j++) {
t = 1 << (i + 1);
if (j & t) {
dp[i + 1][j] += dp[i][j];
dp[i + 1][j - t] += dp[i][j];
} else {
dp[i + 1][j] += dp[i][j];
}
}
ans = 0;
for (j = 0; j < mask; j++) {
t = 1;
for (i = 0; i < 20; i++)
if ((1 << i) & j) t = -t;
tt = q_pow(2, dp[19][j], mod);
ans += t * tt;
if (ans >= mod) ans -= mod;
if (ans < 0) ans += mod;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long f[21][1 << 20];
long long pow2[1 << 20];
int main() {
for (int i = 0; i < (int)(1 << 20); i++) {
if (i == 0)
pow2[0] = 1;
else
pow2[i] = (pow2[i - 1] * 2) % (1000000007L);
}
memset(f, 0, sizeof f);
scanf("%d", &n);
int x, maxi = 0;
for (int i = 0; i < (int)n; i++) {
scanf("%d", &x);
maxi = max(maxi, x);
f[0][x]++;
}
m = 0;
while (maxi > 0) {
maxi = maxi >> 1;
m++;
}
for (int k = 1; k <= m; k++) {
for (int i = 0; i < (1 << 20); i++) {
if (((i >> k - 1) & 1)) {
f[k][i] = f[k - 1][i];
} else {
f[k][i] = (f[k - 1][i] + f[k - 1][(i | ((1 << k - 1)))]) %
((1000000007L) - 1);
}
}
}
long long sum = 0;
for (int i = 0; i < (1 << 20); i++) {
if (__builtin_popcount(i) % 2 == 0) {
sum = (sum + (pow2[f[m][i]] - 1)) % (1000000007L);
} else
sum = (sum - (pow2[f[m][i]] - 1)) % (1000000007L);
}
sum = (sum + (1000000007L)) % (1000000007L);
cout << sum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace Bit {
const int bcnt{20};
const int size{1 << bcnt};
const int full{size - 1};
inline int size_of(int n) {
int r = 1;
while (n >>= 1) r++;
return r;
}
inline int count(int mask) { return __builtin_popcount(mask); }
inline int at(int mask, int b) { return mask >> b & 1; }
inline int flip(int mask) { return full ^ mask; }
inline int flip_b(int mask, int b) { return mask ^ (1 << b); }
inline int parity(int mask) { return __builtin_parity(mask); }
inline void print(int mask) {
cout << "bitset<32>(mask)"
<< " = " << (bitset<32>(mask)) << "\n";
}
}; // namespace Bit
const int MOD = 1e9 + 7;
struct mint {
int v;
mint(int v = 0) : v(v){};
inline bool operator==(const mint &b) { return v == b.v; }
inline void operator+=(const mint &b) {
if ((v += b.v) >= MOD) v -= MOD;
}
inline void operator-=(const mint &b) {
if ((v += MOD - b.v) >= MOD) v -= MOD;
}
inline void operator*=(const mint &b) { v = v * 1ll * b.v % MOD; }
inline mint operator^(int b) const {
mint r{1};
for (auto a = *this; b; b >>= 1) {
if (b & 1) r *= a;
a *= a;
}
return r;
}
inline mint inv() const { return operator^(MOD - 2); }
inline void operator/=(const mint &b) { operator*=(b.inv()); }
};
inline mint operator+(const mint &a, const mint &b) {
auto r = a;
r += b;
return r;
}
inline mint operator-(const mint &a, const mint &b) {
auto r = a;
r -= b;
return r;
}
inline mint operator*(const mint &a, const mint &b) {
auto r = a;
r *= b;
return r;
}
inline mint operator/(const mint &a, const mint &b) {
auto r = a;
r /= b;
return r;
}
const int N = 1e6 + 7;
int a[N];
mint pw2[N];
static void glo_init() {
pw2[0] = 1;
for (int i = 1; i < N; i++) pw2[i] = pw2[i - 1] + pw2[i - 1];
}
int subcnt[Bit::size];
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) subcnt[Bit::flip(a[i])] += 1;
for (int b = 0; b < Bit::bcnt; b++) {
for (int mask = 0; mask < Bit::size; mask++) {
if (!Bit::at(mask, b)) continue;
subcnt[mask] += subcnt[Bit::flip_b(mask, b)];
}
}
mint res = pw2[n];
for (int mask = 1; mask < Bit::size; mask++) {
int supcnt = subcnt[Bit::flip(mask)];
bool is_positive = Bit::parity(mask) == false;
if (is_positive)
res += pw2[supcnt];
else
res -= pw2[supcnt];
}
cout << res.v << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
glo_init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read();
const int N = 1 << 21, P = 1000000007;
int n, mx, h;
int a[N], g[N], bitcnt[N], pw[N];
void fwt(int *a) {
for (int l = 2, mid = 1; l <= h; l <<= 1, mid <<= 1)
for (int *p = a; p != a + h; p += l)
for (int i = 0; i < mid; ++i) p[i] += p[i + mid];
}
int mo(int x) { return x >= P ? x - P : x; }
int main() {
n = read();
for (int i = 1, x; i <= n; ++i) ++g[x = read()], mx = max(mx, x);
h = 1;
while (h <= mx) h <<= 1;
fwt(g);
pw[0] = 1;
for (int(i) = (1); (i) <= (n); ++(i)) pw[i] = mo(pw[i - 1] + pw[i - 1]);
int ans = 0;
for (int i = 0; i < h; ++i) {
bitcnt[i] = bitcnt[i >> 1] + (i & 1);
int res = mo(pw[g[i]] - 1 + P);
if (bitcnt[i] & 1)
ans = mo(ans - res + P);
else
ans = mo(ans + res);
}
printf("%d\n", ans);
return 0;
}
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 ^ 48), c = getchar();
return f * x;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y) {
long long int res = 1;
while (y) {
if (y & 1) res = (res * x) % 1000000007;
y = y / 2, x = (x * x) % 1000000007;
}
return res % 1000000007;
}
long long int dp[1 << 22];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
long long int i, j;
for (i = 0; i < n; i++) {
long long int k;
cin >> k;
dp[k]++;
}
for (i = 0; i < 20; i++) {
for (j = 0; j < (1 << 20); j++) {
if (!(j & (1 << i))) dp[j] += (dp[j ^ (1 << i)]);
}
}
for (i = 0; i < (1 << 20); i++) {
dp[i] = (power(2, dp[i]) - 1 + 1000000007) % 1000000007;
}
for (i = 0; i < 20; i++) {
for (j = 0; j < (1 << 20); j++) {
if (!(j & (1 << i)))
dp[j] = (dp[j] - (dp[j ^ (1 << i)]) + 1000000007) % 1000000007;
}
}
cout << dp[0];
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1 << 20][21];
int d[1 << 20];
int pow1[1 << 20];
int main() {
int i, j, n, ans, cnt, x, k;
pow1[0] = 1;
for (i = 1; i < (1 << 20); i++) {
pow1[i] = pow1[i - 1] + pow1[i - 1];
if (pow1[i] >= 1000000007) pow1[i] -= 1000000007;
}
for (i = 0; i < (1 << 20); i++) {
pow1[i]--;
if (pow1[i] < 0) pow1[i] += 1000000007;
}
scanf("%d", &n);
memset(a, 0, sizeof(a));
for (i = 0; i < n; i++) {
scanf("%d", &x);
a[x][20]++;
}
memset(d, 0, sizeof(d));
for (i = (1 << 20) - 1; i >= 0; i--)
for (j = 0; j < 21; j++)
if (a[i][j] > 0) {
d[i] += a[i][j];
for (k = j - 1; k >= 0; k--)
if (((1 << k) & i) != 0) a[i ^ (1 << k)][k] += a[i][j];
}
ans = 0;
for (i = 1; i < (1 << 20); i++) {
cnt = 0;
for (j = 0; j < 20; j++)
if (((1 << j) & i) != 0) cnt++;
if (cnt % 2 == 0) {
ans -= pow1[d[i]];
if (ans < 0) ans += 1000000007;
} else {
ans += pow1[d[i]];
if (ans >= 1000000007) ans -= 1000000007;
}
}
ans = pow1[n] - ans;
if (ans < 0) ans += 1000000007;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sum[1 << 20];
const int P = 1e9 + 7;
int power(int a, int b) {
int ans = 1, z = a;
for (; b; b >>= 1, z = (long long)z * z % P)
if (b & 1) ans = (long long)ans * z % P;
return ans;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
++sum[x];
}
for (int i = 0; i < 20; ++i)
for (int j = 0; j < 1 << 20; ++j)
if (j >> i & 1) sum[j ^ (1 << i)] += sum[j];
int ans = 0;
for (int opt = 0; opt < 1 << 20; ++opt) {
int ans1 = power(2, sum[opt]) - 1;
if (ans1 < 0) ans1 += P;
int cur = 0;
for (int i = opt; i; i -= i & -i) cur ^= 1;
if (!cur)
ans += ans1;
else
ans -= ans1;
if (ans < 0) ans += P;
ans %= P;
}
printf("%d\n", ans);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.