text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int MD = 1000000007;
int n, m, q, cnt[N];
int fi[N], a[N];
int l[N], r[N], lst[N];
long long val[N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
fi[1] = fi[2] = 1 % m;
for (int i = 3; i < N; ++i) fi[i] = (fi[i - 1] + fi[i - 2]) % m;
for (int i = 1; i <= n; ++i) cin >> a[i];
cin >> q;
vector<pair<int, int> > v;
for (int i = 1; i <= n; ++i) v.push_back(make_pair(a[i], i));
sort(v.begin(), v.end());
for (int _tmp = q, i = 1; i <= _tmp; ++i) cin >> l[i] >> r[i];
for (int i = 0; i < v.size(); ++i) {
int x = v[i].first, y = v[i].second;
for (int _tmp = q, j = 1; j <= _tmp; ++j)
if (l[j] <= y && y <= r[j] && lst[j] < x) {
lst[j] = x;
cnt[j]++;
val[j] += 1LL * fi[cnt[j]] * x;
}
}
for (int _tmp = q, i = 1; i <= _tmp; ++i) cout << val[i] % m << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 3e4 + 9;
pair<int, int> a[MAX];
int n, m, f[MAX], q, ans[MAX], l[MAX], r[MAX], h[MAX], las[MAX];
int main() {
cin >> n >> m, f[1] = 1, f[2] = 1;
for (int i = 3; i <= n; i++) f[i] = (f[i - 1] + f[i - 2]) % m;
for (int i = 1; i <= n; i++) cin >> a[i].first, a[i].second = i;
sort(a + 1, a + n + 1);
cin >> q;
for (int i = 1; i <= q; i++) cin >> l[i] >> r[i], las[i] = -1;
for (int i = 1; i <= n; i++) {
int t = a[i].first % m;
for (int j = 1; j <= q; j++)
if (a[i].second >= l[j] && a[i].second <= r[j] && a[i].first != las[j])
las[j] = a[i].first, ans[j] = (ans[j] + f[++h[j]] * t) % m;
}
for (int i = 1; i <= q; i++) cout << ans[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int sq = 179, MAXN = 3e4 + 10;
int n, Mod, x;
int ans[MAXN], f[MAXN], last[MAXN], now[MAXN], l[MAXN], r[MAXN], s, e;
pair<int, int> a[MAXN];
int main() {
ios::sync_with_stdio(false);
scanf("%d%d", &n, &Mod);
for (int i = 0; i < n; i++) scanf("%d", &a[i].first), a[i].second = i;
f[0] = 1;
f[1] = 1;
for (int i = 2; i <= n; i++) f[i] = (f[i - 1] + f[i - 2]) % Mod;
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d%d", &l[i], &r[i]);
l[i]--;
}
sort(a, a + n);
memset(last, -1, sizeof last);
for (int i = 0; i < n; i++) {
x = a[i].first;
a[i].first %= Mod;
for (int j = 0; j < q; j++)
if (l[j] <= a[i].second and r[j] > a[i].second and last[j] != x) {
ans[j] = (ans[j] + f[now[j]++] * a[i].first) % Mod;
last[j] = x;
}
}
for (int i = 0; i < q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
int n, m, a[30001], orig[30001], q, F[30001];
struct info {
int f, g, siz;
} se[300001];
struct query {
int l, r, ord;
} num[30001];
int pos[30001], ans[30001], cnt[30001], lim;
bool cmp(query a, query b) {
return pos[a.l] != pos[b.l] ? a.l < b.l : ((pos[a.l] & 1) ^ (a.r < b.r));
}
info merge(info a, info b) {
if (!b.siz) return a;
return (info){(a.f * F[b.siz + 1] + a.g * F[b.siz] + b.f) % m,
(a.f * F[b.siz] + a.g * F[b.siz - 1] + b.g) % m, a.siz + b.siz};
}
void update(int root, int l, int r, int e) {
if (l == r) {
if (cnt[l])
se[root] = (info){orig[l], 0, 1};
else
se[root] = (info){0, 0, 0};
return;
}
if ((l + r) >> 1 >= e)
update(root << 1, l, (l + r) >> 1, e);
else
update(root << 1 | 1, ((l + r) >> 1) + 1, r, e);
se[root] = merge(se[root << 1 | 1], se[root << 1]);
}
void add(int x) {
if (!(cnt[a[x]]++)) update(1, 1, lim, a[x]);
}
void del(int x) {
if (!(--cnt[a[x]])) update(1, 1, lim, a[x]);
}
signed main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
orig[i] = a[i];
}
std::sort(orig + 1, orig + n + 1);
lim = std::unique(orig + 1, orig + n + 1) - orig - 1;
for (int i = 1; i <= n; i++)
a[i] = std::lower_bound(orig + 1, orig + lim + 1, a[i]) - orig;
for (int i = 1; i <= lim; i++) orig[i] %= m;
F[1] = F[2] = 1;
for (int i = 3; i <= n; i++) F[i] = (F[i - 1] + F[i - 2]) % m;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &num[i].l, &num[i].r);
num[i].ord = i;
}
int bl = (int)sqrt(n);
for (int i = 1; i <= n; i++) pos[i] = (i - 1) / bl + 1;
std::sort(num + 1, num + q + 1, cmp);
for (int i = 1, l = 1, r = 0; i <= q; i++) {
while (r < num[i].r) add(++r);
while (l > num[i].l) add(--l);
while (l < num[i].l) del(l++);
while (r > num[i].r) del(r--);
ans[num[i].ord] = se[1].f;
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 30005;
int Q, B;
struct query {
int l, r, id;
bool operator<(const query &R) const {
int i = l / B, j = R.l / B;
if (i != j) return i < j;
if (i & 1)
return r < R.r;
else
return R.r < r;
}
} q[N];
int n, m, a[N], d[N], D;
int cnt[N], res[N];
int fib[N][2];
struct stree {
int a0, a1;
int s;
} t[N << 1];
inline int id(int l, int r) { return l + r | l != r; }
void pushup(int p, int l, int mid, int r) {
int L = id(l, mid), R = id(mid + 1, r);
t[p].s = t[L].s + t[R].s;
t[p].a0 =
(t[L].a0 + fib[t[L].s][0] * t[R].a0 % Q + fib[t[L].s][1] * t[R].a1 % Q) %
Q;
t[p].a1 = (t[L].a1 + fib[t[L].s][0] * t[R].a1 % Q +
fib[t[L].s][1] * (t[R].a0 + t[R].a1) % Q) %
Q;
}
void modify(int l, int r, int x, int w) {
int p = id(l, r);
if (l == r) {
t[p].s = w;
t[p].a0 = t[p].a1 = w * d[x] % Q;
return;
}
int mid = l + r >> 1;
if (x <= mid)
modify(l, mid, x, w);
else
modify(mid + 1, r, x, w);
pushup(p, l, mid, r);
}
void add(int i) {
int x = a[i];
if (++cnt[x] == 1) {
modify(0, D, x, 1);
}
}
void del(int i) {
int x = a[i];
if (--cnt[x] == 0) {
modify(0, D, x, 0);
}
}
int main() {
scanf("%d%d", &n, &Q);
B = sqrt(n);
fib[0][0] = 1, fib[1][1] = 1;
for (int i = 2; i <= n + 1; ++i) {
fib[i][0] = (fib[i - 2][0] + fib[i - 1][0]) % Q;
fib[i][1] = (fib[i - 2][1] + fib[i - 1][1]) % Q;
}
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
d[D++] = a[i];
}
sort(d, d + D);
D = unique(d, d + D) - d;
for (int i = 0; i < n; ++i) {
a[i] = lower_bound(d, d + D, a[i]) - d;
}
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
q[i] = (query){--x, --y, i};
}
sort(q, q + m);
int l = 0, r = -1;
for (int i = 0; i < m; ++i) {
while (r < q[i].r) {
add(++r);
}
while (l > q[i].l) {
add(--l);
}
while (r > q[i].r) {
del(r--);
}
while (l < q[i].l) {
del(l++);
}
res[q[i].id] = t[id(0, D)].a0 % Q;
}
for (int i = 0; i < m; ++i) printf("%d\n", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e4 + 1;
int n, m, q, f[N], a[N];
vector<int> vec;
bitset<N> bit;
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
vec.push_back(a[i]);
}
f[1] = f[2] = 1;
for (int i = 3; i <= n; i++) {
f[i] = (f[i - 1] + f[i - 2]) % m;
}
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
for (int i = 1; i <= n; i++) {
a[i] = lower_bound(vec.begin(), vec.end(), a[i]) - vec.begin();
}
scanf("%d", &q);
while (q--) {
int l, r, cn = 1;
long long ans = 0;
scanf("%d %d", &l, &r);
for (int i = l; i <= r; i++) {
bit[a[i]] = 1;
}
for (int i = 0; i < vec.size(); i++) {
if (bit[i]) {
ans = (ans + vec[i] * 1ll * f[cn++]) % m;
bit[i] = 0;
}
}
printf("%I64d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = int(3e4) + 10;
int n, moder, m;
int a[maxn];
set<int> st;
map<int, int> v;
int tot = 0;
pair<int, int> q[maxn], w[maxn];
long long ans[maxn], fib[maxn];
int now[maxn], cnt[maxn];
int main() {
scanf("%d%d", &n, &moder);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
st.insert(a[i]);
}
for (set<int>::iterator it = st.begin(); it != st.end(); it++) v[*it] = ++tot;
fib[1] = fib[2] = 1;
for (int i = 3; i <= n; i++) fib[i] = (fib[i - 1] + fib[i - 2]) % moder;
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d%d", &q[i].first, &q[i].second);
for (int i = 1; i <= n; i++) w[i] = make_pair(a[i], i);
sort(w + 1, w + 1 + n);
for (int i = 1; i <= n; i++) {
int val = w[i].first, pos = v[val];
int id = w[i].second;
for (int j = 1; j <= m; j++)
if (q[j].first <= id && id <= q[j].second && now[j] < pos) {
now[j] = pos;
cnt[j]++;
ans[j] += fib[cnt[j]] * val;
}
}
for (int i = 1; i <= m; i++) printf("%I64d\n", ans[i] % moder);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2, 3, "Ofast")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
const double pi = 3.141592653589793238462643383279;
namespace MyMinMax {
template <typename T>
inline T mn(const T x, const T y) {
return x < y ? x : y;
}
template <typename T>
inline T mx(const T x, const T y) {
return x > y ? x : y;
}
template <typename T>
inline bool chmin(T &x, const T y) {
return (x > y) && ((x = y), 1);
}
template <typename T>
inline bool chmax(T &x, const T y) {
return (x < y) && ((x = y), 1);
}
template <typename T, typename... Args>
inline T mx(const T x, const Args... args) {
return mx(x, mx(args...));
}
template <typename T, typename... Args>
inline T mn(const T x, const Args... args) {
return mn(x, mn(args...));
}
} // namespace MyMinMax
using namespace MyMinMax;
namespace IO {
const int DPAIRSIZ = 1 << 18;
char BB[DPAIRSIZ], *SS = BB, *TT = BB;
inline char getcha() {
return SS == TT && (TT = (SS = BB) + fread(BB, 1, DPAIRSIZ, stdin), SS == TT)
? EOF
: *SS++;
}
template <typename T = int>
inline T read() {
T x = 0;
int fu = 1;
char c = getcha();
while (c > 57 || c < 48) {
if (c == 45) fu = -1;
c = getcha();
}
while (c <= 57 && c >= 48) {
x = x * 10 + c - 48;
c = getcha();
}
x *= fu;
return x;
}
template <typename T>
inline void read(T &x) {
x = 0;
int fu = 1;
char c = getcha();
while (c > 57 || c < 48) {
if (c == 45) fu = -1;
c = getcha();
}
while (c <= 57 && c >= 48) {
x = x * 10 + c - 48;
c = getcha();
}
x *= fu;
}
template <typename T>
inline void read(T *bg, T *ed) {
while (bg != ed) read(*bg++);
}
inline void read(char &ch) {
ch = getcha();
while (ch <= 32) ch = getcha();
}
inline void read(char *s) {
char ch = getcha();
while (ch <= 32) ch = getcha();
while (ch > 32) *s++ = ch, ch = getcha();
*s = '\0';
}
inline void sread(char *s) {
char ch = getcha();
while (ch < 32) ch = getcha();
while (ch >= 32) *s++ = ch, ch = getcha();
*s = '\0';
}
inline void pread(char *&s) {
char ch = getcha();
while (ch <= 32) ch = getcha();
while (ch > 32) *s++ = ch, ch = getcha();
*s = '\0';
}
inline void spread(char *&s) {
char ch = getcha();
while (ch < 32) ch = getcha();
while (ch >= 32) *s++ = ch, ch = getcha();
*s = '\0';
}
template <typename T, typename... Args>
inline void read(T &x, Args &...args) {
read(x);
read(args...);
}
char out[DPAIRSIZ], *Out = out;
inline void putcha(char x) {
*Out++ = x;
if (Out - out >= (DPAIRSIZ)) fwrite(out, 1, Out - out, stdout), Out = out;
}
template <typename T>
inline void fprint(T x) {
if (x < 0) putcha(45), x = -x;
if (x > 9) fprint(x / 10);
putcha(x % 10 + 48);
}
inline void print() { putcha(10); }
template <typename T>
inline void print(T x) {
fprint(x);
putcha(10);
}
inline void print(char *ch) {
while (*ch != '\0') putcha(*(ch++));
putcha(10);
}
inline void put(char *ch) {
while (*ch != '\0') putcha(*(ch++));
}
inline void print(const char *ch) {
while (*ch != '\0') putcha(*(ch++));
putcha(10);
}
inline void put(const char *ch) {
while (*ch != '\0') putcha(*(ch++));
}
template <typename T, typename... Args>
inline void print(T x, Args... args) {
fprint(x);
putcha(32);
print(args...);
}
template <typename... Args>
inline void print(const char *ch, Args... args) {
while (*ch != '\0') putcha(*(ch++));
putcha(32);
print(args...);
}
template <typename... Args>
inline void print(char *ch, Args... args) {
while (*ch != '\0') putcha(*(ch++));
putcha(32);
print(args...);
}
template <typename T, typename... Args>
inline void printl(T x, Args... args) {
fprint(x);
putcha(10);
printl(args...);
}
template <typename... Args>
inline void printl(const char *ch, Args... args) {
while (*ch != '\0') putcha(*(ch++));
putcha(10);
printl(args...);
}
template <typename... Args>
inline void printl(char *ch, Args... args) {
while (*ch != '\0') putcha(*(ch++));
putcha(10);
printl(args...);
}
template <typename T>
inline void sprint(T x) {
fprint(x);
putcha(32);
}
template <typename T, typename... Args>
inline void sprint(T x, Args... args) {
fprint(x);
putcha(32);
sprint(args...);
}
template <typename T>
inline void sprint(T *bg, T *ed) {
while (bg != ed) sprint(*bg++);
}
template <typename T>
inline void print(T *bg, T *ed) {
while (bg != ed) sprint(*bg++);
putcha(10);
}
template <typename T>
inline void printl(T *bg, T *ed) {
while (bg != ed) print(*bg++);
}
class AutoFlush {
public:
~AutoFlush() { fwrite(out, 1, Out - out, stdout); }
} __AutoFlush;
} // namespace IO
using namespace IO;
const int INF = 0x3f3f3f3f;
const long long INFll = 0x3f3f3f3f3f3f3f3fll;
const int MAXN = 3e4 + 5;
int f[MAXN], m, a[MAXN], n, q;
inline void init() {
f[0] = f[1] = 1;
for (int i = (2); i <= (n); ++i)
((f[i] = f[i - 1] + f[i - 2]) >= m) && (f[i] -= m);
}
int b[MAXN];
namespace DPair {
int cnt1[256], cnt2[256], cnt3[256], cnt4[256], A[MAXN];
inline void RadixSort(int *a, const int N) {
for (int i = (0); i < (N); ++i) {
++cnt1[a[i] & 255];
++cnt2[a[i] >> 8 & 255];
++cnt3[a[i] >> 16 & 255];
++cnt4[a[i] >> 24 & 255];
}
for (int i = (1); i < (256); ++i) {
cnt1[i] += cnt1[i - 1];
cnt2[i] += cnt2[i - 1];
cnt3[i] += cnt3[i - 1];
cnt4[i] += cnt4[i - 1];
}
for (int i = (N - 1); i >= (0); --i) A[--cnt1[a[i] & 255]] = a[i];
for (int i = (N - 1); i >= (0); --i) a[--cnt2[A[i] >> 8 & 255]] = A[i];
for (int i = (N - 1); i >= (0); --i) A[--cnt3[a[i] >> 16 & 255]] = a[i];
for (int i = (N - 1); i >= (0); --i) a[--cnt4[A[i] >> 24 & 255]] = A[i];
memset(cnt1, 0, sizeof(cnt1));
memset(cnt2, 0, sizeof(cnt2));
memset(cnt3, 0, sizeof(cnt3));
memset(cnt4, 0, sizeof(cnt4));
}
inline void RadixSort(int *a, int *_a) {
int N = _a - a;
while (N & 3) a[N++] = INF;
RadixSort(a, N);
}
} // namespace DPair
signed main() {
read(n, m);
read(a + 1, a + n + 1);
init();
read(q);
while (q--) {
int l, r;
read(l, r);
const int len = (r - l + 1);
memcpy(b, a + l, len * sizeof(int));
DPair ::RadixSort(b, b + len);
const int p = std ::unique(b, b + len) - b;
int ans[4] = {0, 0, 0, 0};
for (int i = 0; i < p - 3; i += 4) {
ans[0] = (1ll * b[i] * f[i] + ans[0]) % m;
ans[1] = (1ll * b[i + 1] * f[i + 1] + ans[1]) % m;
ans[2] = (1ll * b[i + 2] * f[i + 2] + ans[2]) % m;
ans[3] = (1ll * b[i + 3] * f[i + 3] + ans[3]) % m;
}
switch (p & 3) {
case 3:
ans[0] = (1ll * b[p - 3] * f[p - 3] + ans[0]) % m;
case 2:
ans[0] = (1ll * b[p - 2] * f[p - 2] + ans[0]) % m;
case 1:
ans[0] = (1ll * b[p - 1] * f[p - 1] + ans[0]) % m;
}
print((ans[0] + ans[1] + ans[2] + ans[3]) % m);
}
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx")
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
using namespace std;
const int N = 30010;
void read(int &x) {
char c = getchar();
x = 0;
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - 48, c = getchar();
}
void write(long long x) {
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
struct gg {
int a, id, b;
} mp[N];
int Q, n, m, F[N];
bool cmp(gg x, gg y) { return x.a < y.a; }
int main() {
register int i, j;
read(n), read(m);
F[1] = F[2] = 1 % m;
for (i = 3; i <= n; i++) F[i] = (F[i - 1] + F[i - 2]) % m;
for (i = 1; i <= n; i++) {
read(mp[i].a);
mp[i].id = i;
mp[i].b = mp[i].a % m;
}
sort(mp + 1, mp + n + 1, cmp);
read(Q);
int l, r, las, cnt;
long long ans;
for (i = 1; i <= Q; i++) {
las = -1, ans = 0, cnt = 0;
read(l), read(r);
for (j = 1; j <= n; j++) {
if (mp[j].id >= l && mp[j].id <= r) {
if (mp[j].a != las) ans += mp[j].b * F[++cnt], las = mp[j].a;
}
}
write(ans % m), puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 30000;
const int blocks = 250;
struct Query {
int l, r, id;
bool operator<(const Query &rhs) const {
return l / blocks < rhs.l / blocks ||
(l / blocks == rhs.l / blocks && r < rhs.r);
}
};
int tot;
int mod;
int tree[maxn << 2][2];
int lazy[maxn << 2][2][2];
void build(int rt = 1, int l = 0, int r = tot - 1) {
lazy[rt][0][0] = lazy[rt][1][1] = 1;
if (l < r) {
int m = (l + r) >> 1;
build(rt << 1, l, m);
build(rt << 1 | 1, m + 1, r);
}
}
void push_up(int rt) {
tree[rt][0] = tree[rt << 1][0] + tree[rt << 1 | 1][0];
if (tree[rt][0] >= mod) tree[rt][0] -= mod;
tree[rt][1] = tree[rt << 1][1] + tree[rt << 1 | 1][1];
if (tree[rt][1] >= mod) tree[rt][1] -= mod;
int a0 = lazy[rt][0][0] * tree[rt][0] + lazy[rt][0][1] * tree[rt][1];
int a1 = lazy[rt][1][0] * tree[rt][0] + lazy[rt][1][1] * tree[rt][1];
tree[rt][0] = a0 % mod;
tree[rt][1] = a1 % mod;
}
void update2(int x, int val, int rt = 1, int l = 0, int r = tot - 1) {
if (l >= r) {
tree[rt][0] = val * lazy[rt][0][0] % mod;
tree[rt][1] = val * lazy[rt][1][0] % mod;
return;
}
int m = (l + r) >> 1;
if (x <= m)
update2(x, val, rt << 1, l, m);
else
update2(x, val, rt << 1 | 1, m + 1, r);
push_up(rt);
}
int tmp[2][2];
void update(int L, int R, int val, bool flag, int rt = 1, int l = 0,
int r = tot - 1) {
if (L <= l && r <= R) {
if (flag) {
tree[rt][0] = tree[rt][0] + tree[rt][1];
tree[rt][1] = tree[rt][0] - tree[rt][1];
if (tree[rt][0] >= mod) tree[rt][0] -= mod;
lazy[rt][0][0] = lazy[rt][0][0] + lazy[rt][1][0];
lazy[rt][1][0] = lazy[rt][0][0] - lazy[rt][1][0];
if (lazy[rt][0][0] >= mod) lazy[rt][0][0] -= mod;
lazy[rt][0][1] = lazy[rt][0][1] + lazy[rt][1][1];
lazy[rt][1][1] = lazy[rt][0][1] - lazy[rt][1][1];
if (lazy[rt][0][1] >= mod) lazy[rt][0][1] -= mod;
} else {
tree[rt][1] = tree[rt][0] - tree[rt][1];
tree[rt][0] = tree[rt][0] - tree[rt][1];
if (tree[rt][1] < 0) tree[rt][1] += mod;
lazy[rt][1][0] = lazy[rt][0][0] - lazy[rt][1][0];
lazy[rt][0][0] = lazy[rt][0][0] - lazy[rt][1][0];
if (lazy[rt][1][0] < 0) lazy[rt][1][0] += mod;
lazy[rt][1][1] = lazy[rt][0][1] - lazy[rt][1][1];
lazy[rt][0][1] = lazy[rt][0][1] - lazy[rt][1][1];
if (lazy[rt][1][1] < 0) lazy[rt][1][1] += mod;
}
if (l == L) update2(L, val, rt, l, r);
return;
}
int m = (l + r) >> 1;
if (L <= m) update(L, R, val, flag, rt << 1, l, m);
if (R > m) update(L, R, val, flag, rt << 1 | 1, m + 1, r);
push_up(rt);
}
map<int, int> mp;
int a[maxn];
int val[maxn];
Query query[maxn];
int cnt[maxn];
int ans[maxn];
void add(int x) {
if (cnt[x] == 0) update(x, tot - 1, val[x], 1);
cnt[x]++;
}
void sub(int x) {
cnt[x]--;
if (cnt[x] == 0) update(x, tot - 1, 0, 0);
}
int main() {
int n;
scanf("%d %d", &n, &mod);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
mp[a[i]] = 0;
}
for (auto &p : mp) val[p.second = tot++] = p.first;
for (int i = 0; i < n; ++i) a[i] = mp[a[i]];
build();
int q;
scanf("%d", &q);
for (int i = 0; i < q; ++i)
scanf("%d %d", &query[i].l, &query[i].r), query[i].id = i;
sort(query, query + q);
int l = 1, r = 0;
for (int i = 0; i < q; ++i) {
while (query[i].l < l) {
--l;
add(a[l - 1]);
}
while (query[i].l > l) {
sub(a[l - 1]);
++l;
}
while (query[i].r < r) {
sub(a[r - 1]);
--r;
}
while (query[i].r > r) {
++r;
add(a[r - 1]);
}
ans[query[i].id] = tree[1][1];
}
for (int i = 0; i < q; ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n, q, MOD, f[maxn], L[maxn], R[maxn], stp[maxn], lst[maxn], ans[maxn];
pair<int, int> a[maxn];
int main() {
scanf("%d%d", &n, &MOD);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].first), a[i].second = i;
f[1] = 1;
for (int i = 2; i <= n; i++) f[i] = (f[i - 1] + f[i - 2]) % MOD;
sort(a + 1, a + 1 + n);
scanf("%d", &q);
for (int i = 1; i <= q; i++) scanf("%d%d", &L[i], &R[i]);
for (int i = 1; i <= n; i++) {
int d = a[i].first % MOD, id = a[i].second;
for (int j = 1; j <= q; j++)
if (L[j] <= id && id <= R[j] && lst[j] != a[i].first)
(ans[j] += f[++stp[j]] * d) %= MOD, lst[j] = a[i].first;
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
const int BLOCK = 250;
int m;
int from[N], to[N], res[N];
pair<int, int> ev[N];
int REAL[N], a[N];
int id[N];
inline bool cmp(int x, int y) {
int u = from[x] / BLOCK;
int v = from[y] / BLOCK;
if (u != v) {
return u < v;
}
return to[x] < to[y];
}
int a11[N], a12[N], a13[N];
int a21[N], a22[N], a23[N];
void build(int x, int l, int r) {
a11[x] = 1;
a12[x] = 0;
a13[x] = 0;
a21[x] = 0;
a22[x] = 1;
a23[x] = 0;
if (l < r) {
int y = (l + r) >> 1;
build(x + x, l, y);
build(x + x + 1, y + 1, r);
}
}
void modify(int x, int l, int r, int pos, int action) {
if (l == r) {
if (action == 1) {
a11[x] = 1;
a12[x] = 1;
a13[x] = REAL[pos];
a21[x] = 1;
a22[x] = 0;
a23[x] = 0;
} else {
a11[x] = 1;
a12[x] = 0;
a13[x] = 0;
a21[x] = 0;
a22[x] = 1;
a23[x] = 0;
}
return;
}
int y = (l + r) >> 1;
if (pos <= y) {
modify(x + x, l, y, pos, action);
} else {
modify(x + x + 1, y + 1, r, pos, action);
}
a11[x] = (a11[x + x] * a11[x + x + 1] + a12[x + x] * a21[x + x + 1]) % m;
a12[x] = (a11[x + x] * a12[x + x + 1] + a12[x + x] * a22[x + x + 1]) % m;
a21[x] = (a21[x + x] * a11[x + x + 1] + a22[x + x] * a21[x + x + 1]) % m;
a22[x] = (a21[x + x] * a12[x + x + 1] + a22[x + x] * a22[x + x + 1]) % m;
a13[x] =
(a11[x + x] * a13[x + x + 1] + a12[x + x] * a23[x + x + 1] + a13[x + x]) %
m;
a23[x] =
(a21[x + x] * a13[x + x + 1] + a22[x + x] * a23[x + x + 1] + a23[x + x]) %
m;
}
int t;
int have[N];
int OPS;
void add(int what) {
if (have[what] == 0) {
OPS++;
modify(1, 0, t - 1, what, 1);
}
have[what]++;
}
void del(int what) {
have[what]--;
if (have[what] == 0) {
OPS++;
modify(1, 0, t - 1, what, 0);
}
}
int main() {
int n;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &ev[i].first);
ev[i].second = i;
}
sort(ev, ev + n);
t = -1;
for (int i = 0; i < n; i++) {
if (i == 0 || ev[i].first != ev[i - 1].first) {
t++;
REAL[t] = ev[i].first % m;
}
a[ev[i].second] = t;
}
t++;
for (int i = 0; i < t; i++) {
have[i] = 0;
}
build(1, 0, t - 1);
int tt;
scanf("%d", &tt);
for (int qq = 0; qq < tt; qq++) {
scanf("%d %d", from + qq, to + qq);
from[qq]--;
to[qq]--;
res[qq] = 0;
id[qq] = qq;
}
sort(id, id + tt, cmp);
int ll = from[0], rr = from[0] - 1;
OPS = 0;
for (int qq = 0; qq < tt; qq++) {
while (rr > to[id[qq]]) {
del(a[rr]);
rr--;
}
while (ll < from[id[qq]]) {
del(a[ll]);
ll++;
}
while (rr < to[id[qq]]) {
rr++;
add(a[rr]);
}
while (ll > from[id[qq]]) {
ll--;
add(a[ll]);
}
res[id[qq]] = a13[1];
}
for (int qq = 0; qq < tt; qq++) {
printf("%d\n", (res[qq] % m + m) % m);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, mod;
inline int add(int a, int b) {
if ((a += b) >= mod) a -= mod;
return a;
}
inline int dec(int a, int b) {
if ((a -= b) < 0) a += mod;
return a;
}
inline int mult(int a, int b) {
long long t = 1ll * a * b;
if (t >= mod) t %= mod;
return t;
}
int F[30010], val[30010], a[30010], pt[30010], End;
class sgt {
public:
int sum[120010][2], cnt[120010];
void pushup(int p) {
cnt[p] = cnt[(p << 1)] + cnt[((p << 1) | 1)];
if (cnt[(p << 1)]) {
sum[p][0] = add(add(mult(F[cnt[(p << 1)] - 1], sum[((p << 1) | 1)][0]),
mult(F[cnt[(p << 1)]], sum[((p << 1) | 1)][1])),
sum[(p << 1)][0]);
sum[p][1] = add(add(mult(F[cnt[(p << 1)]], sum[((p << 1) | 1)][0]),
mult(F[cnt[(p << 1)] + 1], sum[((p << 1) | 1)][1])),
sum[(p << 1)][1]);
} else {
sum[p][0] = sum[((p << 1) | 1)][0];
sum[p][1] = sum[((p << 1) | 1)][1];
}
}
inline void modify(int pos, int v) {
int l = 1, r = End, p = 1;
while (l ^ r) {
int mid = (l + r) >> 1;
if (pos <= mid)
p <<= 1, r = mid;
else
p = (p << 1) | 1, l = mid + 1;
}
if (v) {
sum[p][0] = sum[p][1] = val[l];
cnt[p] = 1;
} else {
sum[p][0] = sum[p][1] = 0;
cnt[p] = 0;
}
while (p ^ 1) pushup(p >>= 1);
}
} T;
inline void Add(int v) {
if (!pt[v]) T.modify(v, 1);
++pt[v];
}
inline void Del(int v) {
--pt[v];
if (!pt[v]) T.modify(v, 0);
}
const int blk = 200;
class query {
public:
int l, r, id;
bool operator<(const query &t) const {
if (l / blk != t.l / blk) return l / blk < t.l / blk;
return r < t.r;
}
} q[30010];
int Q, ans[30010];
int main() {
scanf("%d%d", &n, &mod);
F[1] = F[2] = 1;
for (int i = 3; i <= 30001; i++) F[i] = add(F[i - 1], F[i - 2]);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), val[i] = a[i];
sort(val + 1, val + n + 1);
End = unique(val + 1, val + n + 1) - val - 1;
for (int i = 1; i <= n; i++)
a[i] = lower_bound(val + 1, val + End + 1, a[i]) - val;
for (int i = 1; i <= End; i++) val[i] %= mod;
scanf("%d", &Q);
for (int T = 1; T <= Q; T++) {
scanf("%d%d", &q[T].l, &q[T].r);
q[T].id = T;
}
sort(q + 1, q + Q + 1);
for (int i = 1, l = 1, r = 0; i <= Q; i++) {
while (r < q[i].r) Add(a[++r]);
while (l > q[i].l) Add(a[--l]);
while (r > q[i].r) Del(a[r--]);
while (l < q[i].l) Del(a[l++]);
ans[q[i].id] = T.sum[1][0];
}
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 30005;
int Q, B;
struct query {
int l, r, id;
bool operator<(const query &R) const {
int i = l / B, j = R.l / B;
if (i != j) return i < j;
if (i & 1)
return r < R.r;
else
return R.r < r;
}
} q[N];
int n, m, a[N], d[N], D;
int cnt[N], res[N];
int fib[N][2];
struct stree {
int a0, a1;
int s;
} t[N << 1];
inline int id(int l, int r) { return l + r | l != r; }
void pushup(int p, int l, int mid, int r) {
int L = id(l, mid), R = id(mid + 1, r);
t[p].s = t[L].s + t[R].s;
t[p].a0 = (t[L].a0 + fib[t[L].s][0] * t[R].a0 + fib[t[L].s][1] * t[R].a1) % Q;
t[p].a1 = (t[L].a1 + fib[t[L].s][0] * t[R].a1 +
fib[t[L].s][1] * (t[R].a0 + t[R].a1) % Q) %
Q;
}
void modify(int l, int r, int x, int w) {
int p = id(l, r);
if (l == r) {
t[p].s = w;
t[p].a0 = t[p].a1 = w * d[x] % Q;
return;
}
int mid = l + r >> 1;
if (x <= mid)
modify(l, mid, x, w);
else
modify(mid + 1, r, x, w);
pushup(p, l, mid, r);
}
void add(int i) {
int x = a[i];
if (++cnt[x] == 1) {
modify(0, D, x, 1);
}
}
void del(int i) {
int x = a[i];
if (--cnt[x] == 0) {
modify(0, D, x, 0);
}
}
int main() {
scanf("%d%d", &n, &Q);
B = sqrt(n);
fib[0][0] = 1, fib[1][1] = 1;
for (int i = 2; i <= n; ++i) {
fib[i][0] = (fib[i - 2][0] + fib[i - 1][0]) % Q;
fib[i][1] = (fib[i - 2][1] + fib[i - 1][1]) % Q;
}
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
d[D++] = a[i];
}
sort(d, d + D);
D = unique(d, d + D) - d;
for (int i = 0; i < n; ++i) {
a[i] = lower_bound(d, d + D, a[i]) - d;
}
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
q[i] = (query){--x, --y, i};
}
sort(q, q + m);
int l = 0, r = -1;
for (int i = 0; i < m; ++i) {
while (r < q[i].r) {
add(++r);
}
while (l > q[i].l) {
add(--l);
}
while (r > q[i].r) {
del(r--);
}
while (l < q[i].l) {
del(l++);
}
res[q[i].id] = t[id(0, D)].a0 % Q;
}
for (int i = 0; i < m; ++i) printf("%d\n", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx")
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
using namespace std;
const int N = 30000 + 10;
struct Seg {
int l, r, id;
};
int n, m, q, a[N], B, fi[N];
Seg seg[N];
int A(int x, int y) { return ((x += y) >= m) ? (x - m) : x; }
bool cmp(const Seg& a, const Seg& b) {
int t = a.l / B, t2 = b.l / B;
if (t == t2)
return (t & 1) ? (a.r < b.r) : (a.r > b.r);
else
return t < t2;
}
int cnt[N], tot, w[N];
void init() {
for (int i = 1; i <= n; ++i) w[i] = a[i];
sort(w + 1, w + n + 1);
tot = unique(w + 1, w + n + 1) - w - 1;
for (int i = 1; i <= n; ++i) a[i] = lower_bound(w + 1, w + tot + 1, a[i]) - w;
for (int i = 1; i <= tot; ++i) w[i] %= m;
fi[1] = fi[2] = 1 % m;
for (int i = 3; i <= tot + 1; ++i) fi[i] = A(fi[i - 2], fi[i - 1]);
}
int s[N << 2], s2[N << 2], sz[N << 2];
void pull(int o) {
int lc = o << 1, rc = lc ^ 1;
sz[o] = sz[lc] + sz[rc];
if (!sz[lc]) {
s[o] = s[rc];
s2[o] = s2[rc];
} else if (!sz[rc]) {
s[o] = s[lc];
s2[o] = s2[lc];
} else {
s[o] = A(s[lc], A(s2[rc] * fi[sz[lc]] % m, s[rc] * fi[sz[lc] - 1] % m));
s2[o] = A(s2[lc], A(s2[rc] * fi[sz[lc] + 1] % m, s[rc] * fi[sz[lc]] % m));
}
}
void insert(int x, int o = 1, int l = 1, int r = tot) {
if (l == r) {
sz[o] = 1;
s[o] = s2[o] = w[x];
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
insert(x, o << 1, l, mid);
else
insert(x, (o << 1) ^ 1, mid + 1, r);
pull(o);
}
void erase(int x, int o = 1, int l = 1, int r = tot) {
if (l == r) {
sz[o] = 0;
s[o] = s2[o] = 0;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
erase(x, o << 1, l, mid);
else
erase(x, (o << 1) ^ 1, mid + 1, r);
pull(o);
}
void add(int x) {
if (!(cnt[x]++)) insert(x);
}
void del(int x) {
if (!(--cnt[x])) erase(x);
}
int ans[N];
int main() {
scanf("%d%d", &n, &m);
B = sqrt(n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
init();
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
scanf("%d%d", &seg[i].l, &seg[i].r);
seg[i].id = i;
}
sort(seg + 1, seg + q + 1, cmp);
int l = 1, r = 0;
for (int i = 1; i <= q; ++i) {
while (r < seg[i].r) add(a[++r]);
while (l > seg[i].l) add(a[--l]);
while (r > seg[i].r) del(a[r--]);
while (l < seg[i].l) del(a[l++]);
ans[seg[i].id] = s[1];
}
for (int i = 1; i <= q; ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 30011;
int mod;
int a[N], b[N];
int fib[N];
struct SegTree {
int l[N << 2], r[N << 2];
int sz[N << 2];
int v0[N << 2];
int v1[N << 2];
void init(int left, int right, int x = 1) {
l[x] = left;
r[x] = right;
sz[x] = v0[x] = v1[x] = 0;
if (left + 1 != right) {
int mid = (left + right) / 2;
init(left, mid, 2 * x);
init(mid, right, 2 * x + 1);
}
}
void change(int pos, int c, int x = 1) {
if (l[x] + 1 == r[x]) {
sz[x] = c;
v1[x] = (c ? b[pos] : 0) % mod;
} else {
int mid = (l[x] + r[x]) / 2;
if (pos < mid)
change(pos, c, 2 * x);
else
change(pos, c, 2 * x + 1);
sz[x] = sz[2 * x] + sz[2 * x + 1];
if (sz[2 * x]) {
v0[x] = v0[2 * x] + fib[sz[2 * x]] * v1[2 * x + 1] +
fib[sz[2 * x] - 1] * v0[2 * x + 1];
v1[x] = v1[2 * x] + fib[sz[2 * x] + 1] * v1[2 * x + 1] +
fib[sz[2 * x]] * v0[2 * x + 1];
} else {
v0[x] = v0[2 * x + 1];
v1[x] = v1[2 * x + 1];
}
v0[x] %= mod;
v1[x] %= mod;
}
}
int query() { return v1[1]; }
} st;
int Sqrt = 160;
struct Query {
int l, r;
int id;
Query() {}
Query(int l, int r, int id) : l(l), r(r), id(id) {}
bool operator<(const Query &rhs) const {
if (l / Sqrt == rhs.l / Sqrt) return (r < rhs.r) ^ (l / Sqrt % 2 == 1);
return l < rhs.l;
}
} query[N];
int ans[N];
map<int, int> disc;
map<int, int> all;
void add(int pos) {
all[a[pos]]++;
if (all[a[pos]] == 1) st.change(disc[a[pos]], 1);
}
void del(int pos) {
all[a[pos]]--;
if (all[a[pos]] == 0) st.change(disc[a[pos]], 0);
}
int main() {
ios ::sync_with_stdio(false);
int n;
cin >> n >> mod;
Sqrt = (int)sqrt(n) + 1;
fib[1] = fib[2] = 1;
for (int i = 3; i < N; i++) fib[i] = (fib[i - 1] + fib[i - 2]) % mod;
for (int i = 1; i <= n; i++) {
cin >> a[i];
disc[a[i]] = 0;
}
int cnt = 0;
for (auto it = disc.begin(); it != disc.end(); it++) {
b[cnt] = it->first;
it->second = cnt++;
}
st.init(0, cnt);
int m;
cin >> m;
for (int i = 0; i < m; i++) {
cin >> query[i].l >> query[i].r;
query[i].id = i;
}
sort(query, query + m);
int l = 1, r = 0;
for (int i = 0; i < m; i++) {
Query &q = query[i];
while (l > q.l) add(--l);
while (r < q.r) add(++r);
while (l < q.l) del(l++);
while (r > q.r) del(r--);
ans[q.id] = st.query();
}
for (int i = 0; i < m; i++) cout << ans[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 10;
struct Item {
int id, value, mValue;
Item() : id(), value(), mValue() {}
Item(int _id, int _value, int _m) : id(_id), value(_value), mValue(_m) {}
bool operator<(const Item &x) const {
return value < x.value || (value == x.value && id < x.id);
}
};
Item a[N];
int f[N];
int n, m, q;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
a[i].id = i;
scanf("%d", &a[i].value);
a[i].mValue = a[i].value % m;
}
f[0] = f[1] = 1;
for (int i = 2; i < N; i++) f[i] = (f[i - 1] + f[i - 2]) % m;
sort(a, a + n);
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int l, r;
scanf("%d%d", &l, &r);
l--, r--;
int p = -1;
int k = 0;
int ans = 0;
for (int s = 0; s < n; s++) {
if (a[s].id >= l && a[s].id <= r && a[s].value != p) {
p = a[s].value;
ans = (ans + f[k++] * a[s].mValue) % m;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 30010;
struct note {
int val;
int id;
bool operator<(const note &x) const { return val < x.val; }
};
inline void read(int &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') {
f = -1;
}
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
note a[N];
int n, m, q;
int fib[N], l[N], r[N], max_n[N], cnt[N];
long long ans[N];
int main() {
read(n), read(m);
for (int i = 1; i <= n; i++) {
read(a[i].val);
a[i].id = i;
}
sort(a + 1, a + n + 1);
fib[1] = fib[2] = 1;
for (int i = 3; i <= n; i++) {
fib[i] = (fib[i - 1] + fib[i - 2]) % m;
}
read(q);
for (int i = 1; i <= q; i++) {
read(l[i]), read(r[i]);
max_n[i] = -1;
}
for (int i = 1; i <= n; i++) {
int x = a[i].val % m;
for (int j = 1; j <= q; j++) {
if (a[i].id >= l[j] && a[i].id <= r[j] && a[i].val != max_n[j]) {
max_n[j] = a[i].val;
ans[j] += fib[++cnt[j]] * x;
}
}
}
for (int i = 1; i <= q; i++) {
printf("%lld\n", ans[i] % m);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 3e4 + 5;
pair<int, int> a[maxN];
int am[maxN], f[maxN];
int Re() {
int ch = '@', x = 0;
for (; ch < 48 || 57 < ch; ch = getchar())
;
for (; 47 < ch && ch < 58; ch = getchar()) x = x * 10 + ch - 48;
return x;
}
int main() {
int n = Re(), m = Re();
for (int i = 1; i <= n; ++i) {
a[i].first = Re();
a[i].second = i;
}
sort(a + 1, a + 1 + n);
f[0] = 0;
f[1] = 1;
am[1] = a[1].first % m;
for (int i = 2; i <= n; ++i) {
f[i] = f[i - 1] + f[i - 2];
if (f[i] >= m) f[i] -= m;
am[i] = a[i].first % m;
}
int q;
scanf("%d", &q);
for (int i = 1, l, r, last, step, ans; i <= q; ++i) {
l = Re();
r = Re();
last = -1;
step = 0;
ans = 0;
for (int j = 1; j <= n; ++j)
if (l <= a[j].second && a[j].second <= r && a[j].first != last) {
ans = (ans + am[j] * f[++step]) % m;
last = a[j].first;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, li = 0, ri = -1;
int mod;
void upd(int& a, const int& b) { a = (a + b) % mod; }
int add(const int& a, const int& b) { return (a + b) % mod; }
int mul(const int& a, const int& b) { return (a * b) % mod; }
const int maxn = 1 << 15, sqrtn = sqrt(maxn);
struct matrix {
int m[2][2];
matrix() { m[0][0] = m[0][1] = m[1][0] = m[1][1] = 0; }
} s[maxn * 2], m[maxn * 2], m0, m1, m2;
matrix mul(const matrix& a, const matrix& b) {
matrix r;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++) r.m[i][j] += a.m[i][k] * b.m[k][j];
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) r.m[i][j] %= mod;
return r;
}
matrix mul(const matrix& a, const int& b) {
matrix r;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) upd(r.m[i][j], mul(a.m[i][j], b));
return r;
}
matrix add(const matrix& a, const matrix& b) {
matrix r;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) r.m[i][j] = add(a.m[i][j], b.m[i][j]);
return r;
}
vector<int> l(maxn * 2), r(maxn * 2);
void update(int i, int x, int vr = 0) {
if (l[vr] == r[vr]) {
if (x < 0)
s[vr] = m0, m[vr] = m1;
else
s[vr] = mul(m2, x % mod), m[vr] = m2;
return;
}
update(i, x, (i <= r[vr * 2 + 1] ? vr * 2 + 1 : vr * 2 + 2));
m[vr] = mul(m[vr * 2 + 1], m[vr * 2 + 2]);
s[vr] = add(s[vr * 2 + 1], mul(s[vr * 2 + 2], m[vr * 2 + 1]));
}
struct query {
int l, r, i;
};
bool cmp(query& a, query& b) {
if (a.l / sqrtn == b.l / sqrtn)
return ((a.l / sqrtn) & 1) ? a.r < b.r : a.r > b.r;
return a.l < b.l;
}
vector<int> f(maxn, 0), a(maxn), b, id(maxn), ans(maxn, -1);
void add(int i) {
f[id[i]]++;
if (f[id[i]] == 1) update(id[i], a[i]);
}
void rmv(int i) {
f[id[i]]--;
if (f[id[i]] == 0) update(id[i], -a[i]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
m1.m[0][0] = m1.m[1][1] = m2.m[0][0] = m2.m[0][1] = m2.m[1][0] = 1;
for (int i = maxn - 1; i < maxn * 2; i++)
l[i] = r[i] = i - (maxn - 1), m[i] = m1;
for (int i = maxn - 2; i >= 0; i--)
l[i] = l[i * 2 + 1], r[i] = r[i * 2 + 2], m[i] = m1;
cin >> n >> mod;
for (int i = 0; i < n; i++) cin >> a[i], b.push_back(a[i]);
sort(b.begin(), b.end());
b.erase(unique(b.begin(), b.end()), b.end());
for (int i = 0; i < n; i++)
id[i] = lower_bound(b.begin(), b.end(), a[i]) - b.begin();
cin >> q;
vector<query> qu(q);
for (int i = 0; i < q; i++)
cin >> qu[i].l >> qu[i].r, qu[i].l--, qu[i].r--, qu[i].i = i;
sort(qu.begin(), qu.end(), cmp);
for (const query& i : qu) {
while (i.r > ri) add(++ri);
while (i.l < li) add(--li);
while (i.l > li) rmv(li++);
while (i.r < ri) rmv(ri--);
ans[i.i] = s[0].m[0][1];
}
for (int i = 0; i < q; i++) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int ri() {
int x;
scanf("%d", &x);
return x;
}
template <typename T>
inline bool smax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
inline bool smin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const int maxn = 30005;
int n, mod, m = 0;
int a[maxn], id[maxn];
int fib[maxn];
struct seg {
int l, r, d, off;
int x0, x1;
seg *ls, *rs;
seg(int l_, int r_)
: l(l_), r(r_), d(0), off(0), ls(NULL), rs(NULL), x0(0), x1(0) {
if (l < r) {
int mid = (l + r) >> 1;
ls = new seg(l, mid);
rs = new seg(mid + 1, r);
}
}
inline void shift(int x) {
off += x;
d += x;
if (x > 0) {
int tmp = (x0 * fib[x - 1] + x1 * fib[x]) % mod;
x1 = (x0 * fib[x] + x1 * fib[x + 1]) % mod;
x0 = tmp;
} else if (x < 0) {
x = -x;
if (x % 2 == 0) {
int tmp = (x0 * fib[x + 1] - x1 * fib[x]);
x1 = (x1 * fib[x - 1] - x0 * fib[x]);
x0 = tmp;
} else {
int tmp = (x1 * fib[x] - x0 * fib[x + 1]);
x1 = (x0 * fib[x] - x1 * fib[x - 1]);
x0 = tmp;
}
x0 %= mod;
if (x0 < 0) x0 += mod;
x1 %= mod;
if (x1 < 0) x1 += mod;
}
}
inline void down() {
if (d == 0) return;
if (ls) ls->shift(d);
if (rs) rs->shift(d);
d = 0;
}
void add(int pos, int x) {
if (l == r) {
x0 = (x0 + fib[off] * x) % mod;
x1 = (x1 + fib[off + 1] * x) % mod;
return;
}
down();
int mid = (l + r) >> 1;
if (mid < pos) {
rs->add(pos, x);
} else {
ls->add(pos, x);
}
x0 = (ls->x0 + rs->x0);
x1 = (ls->x1 + rs->x1);
if (x0 >= mod) x0 -= mod;
if (x1 >= mod) x1 -= mod;
off = ls->off;
}
void move(int x, int lo, int hi) {
if (x == 0) return;
if (lo <= l && r <= hi) {
shift(x);
return;
}
down();
int mid = (l + r) >> 1;
if (lo <= mid) ls->move(x, lo, hi);
if (hi > mid) rs->move(x, lo, hi);
x0 = (ls->x0 + rs->x0);
x1 = (ls->x1 + rs->x1);
if (x0 >= mod) x0 -= mod;
if (x1 >= mod) x1 -= mod;
off = ls->off;
}
} * tree;
struct query {
int id, l, r;
} q[30000];
int res[30000];
int cnt[maxn];
inline void insert(int x) {
if ((++cnt[id[x]]) == 1) {
tree->move(1, id[x], m);
tree->add(id[x], a[x] % mod);
}
}
inline void remove(int x) {
if ((--cnt[id[x]]) == 0) {
tree->add(id[x], -a[x] % mod);
tree->move(-1, id[x], m);
}
}
int main() {
scanf("%d%d", &n, &mod);
vector<pair<int, int> > v;
for (int i = 0; i < (n); i++) {
scanf("%d", a + i);
v.push_back(pair<int, int>(a[i], i));
}
sort(v.begin(), v.end());
id[v[0].second] = 0;
for (int i = (1); i < (v.size()); i++)
if (v[i].first != v[i - 1].first) {
id[v[i].second] = ++m;
} else {
id[v[i].second] = m;
}
fib[1] = fib[2] = 1;
for (int i = (3); i < (maxn); i++) fib[i] = (fib[i - 1] + fib[i - 2]) % mod;
int Q = ri();
for (int i = 0; i < (Q); i++) {
q[i].id = i;
scanf("%d%d", &q[i].l, &q[i].r);
q[i].l--;
q[i].r--;
}
const int sqr = 300;
sort(q, q + Q, [](query a, query b) {
return a.l / sqr == b.l / sqr ? (((a.l / sqr) & 1) ? a.r > b.r : a.r < b.r)
: a.l / sqr < b.l / sqr;
});
int L = q[0].l, R = q[0].l - 1;
tree = new seg(0, m);
for (int i = 0; i < (Q); i++) {
while (R < q[i].r) insert(++R);
while (L > q[i].l) insert(--L);
while (R > q[i].r) remove(R--);
while (L < q[i].l) remove(L++);
res[q[i].id] = tree->x0;
}
for (int i = 0; i < (Q); i++) printf("%d\n", (res[i] % mod + mod) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M = 1 << 30, A[30000], B[30000], NB, Q, QL[30000], QR[30000],
order[30000], ans[30000];
struct mint {
int x;
mint(const int& x = 0) : x(x % M) {}
friend mint operator+(const mint& a, const mint& b) {
return (a.x + b.x) % M;
}
friend mint operator-(const mint& a, const mint& b) {
return (a.x - b.x) % M;
}
friend mint operator*(const mint& a, const mint& b) {
return (a.x * b.x) % M;
}
operator int() const { return x; }
};
struct vec {
mint x, y;
vec(const mint& x = 0, const mint& y = 0) : x(x), y(y) {}
friend vec operator+(const vec& a, const vec& b) {
return {a.x + b.x, a.y + b.y};
}
friend vec operator-(const vec& a, const vec& b) {
return {a.x - b.x, a.y - b.y};
}
};
struct mat {
mint a, b, c, d;
mat(const mint& a = 1, const mint& b = 0, const mint& c = 0,
const mint& d = 1)
: a(a), b(b), c(c), d(d) {}
friend mat operator*(const mat& a, const mat& b) {
return {a.a * b.a + a.b * b.c, a.a * b.b + a.b * b.d, a.c * b.a + a.d * b.c,
a.c * b.b + a.d * b.d};
}
friend vec operator*(const mat& a, const vec& b) {
return {a.a * b.x + a.b * b.y, a.c * b.x + a.d * b.y};
}
} fib[30000 + 1];
struct seg {
int NN, V[30000];
bool dirty[1 << 17];
pair<vec, int> nodes[1 << 17];
seg(int N) {
for (NN = 1; NN < N;) NN <<= 1;
memset(V, 0, sizeof V);
}
inline pair<vec, int> combine(const pair<vec, int>& a,
const pair<vec, int>& b) {
if (!a.second) return b;
if (!b.second) return a;
return {a.first + fib[a.second] * b.first, a.second + b.second};
}
int _x, _c;
void update(int x, int c) {
V[x] += c;
if (c == 1 && V[x] == 1) _x = x, _c = c, _update(1, 0, NN - 1);
if (c == -1 && V[x] == 0) _x = x, _c = c, _update(1, 0, NN - 1);
}
void _update(int i, int l, int r) {
if (l == r) {
if (_c == 1)
nodes[i] = {{B[l], 0}, 1};
else
nodes[i] = {{0, 0}, 0};
} else {
if (_x <= (l + r) / 2)
_update(2 * i, l, (l + r) / 2);
else
_update(2 * i + 1, (l + r) / 2 + 1, r);
dirty[i] = true;
}
}
void get(int i, int l, int r) {
if (!dirty[i] || l == r) return;
get(2 * i, l, (l + r) / 2);
get(2 * i + 1, (l + r) / 2 + 1, r);
nodes[i] = combine(nodes[2 * i], nodes[2 * i + 1]);
dirty[i] = false;
}
pair<vec, int> query() {
get(1, 0, NN - 1);
return nodes[1];
}
};
int main() {
scanf("%d%d", &N, &M);
for (int i = 0; i < (N); ++i) scanf("%d", &A[i]);
fib[1] = {1, 1, 1, 0};
for (int i = 2; i <= N; ++i) fib[i] = fib[i - 1] * fib[1];
copy(A, A + N, B);
sort(B, B + N);
NB = unique(B, B + N) - B;
for (int i = 0; i < (N); ++i) A[i] = lower_bound(B, B + NB, A[i]) - B;
scanf("%d", &Q);
for (int i = 0; i < (Q); ++i) scanf("%d%d", &QL[i], &QR[i]), --QL[i], --QR[i];
iota(order, order + Q, 0);
int BLOCK = 200;
sort(order, order + Q, [=](const int& i, const int& j) {
int bi = QL[i] / BLOCK, bj = QL[j] / BLOCK;
if (bi != bj)
return bi < bj;
else
return QR[i] < QR[j];
});
int l = 0, r = 0;
seg tree(NB);
tree.update(A[0], 1);
for (int i = 0; i < (Q); ++i) {
while (l > QL[order[i]]) tree.update(A[--l], 1);
while (r < QR[order[i]]) tree.update(A[++r], 1);
while (l < QL[order[i]]) tree.update(A[l++], -1);
while (r > QR[order[i]]) tree.update(A[r--], -1);
ans[order[i]] = tree.query().first.x;
}
for (int i = 0; i < (Q); ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1e9 + 7;
const long long linf = 1ll << 60;
const double dinf = 1e60;
template <typename T>
inline void scf(T &x) {
bool f = 0;
x = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (f) x = -x;
return;
}
template <typename T1, typename T2>
void scf(T1 &x, T2 &y) {
scf(x);
return scf(y);
}
template <typename T1, typename T2, typename T3>
void scf(T1 &x, T2 &y, T3 &z) {
scf(x);
scf(y);
return scf(z);
}
template <typename T1, typename T2, typename T3, typename T4>
void scf(T1 &x, T2 &y, T3 &z, T4 &w) {
scf(x);
scf(y);
scf(z);
return scf(w);
}
inline char mygetchar() {
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
template <typename T>
void chkmax(T &x, const T &y) {
if (y > x) x = y;
return;
}
template <typename T>
void chkmin(T &x, const T &y) {
if (y < x) x = y;
return;
}
const int N = 3e4 + 100;
const int B = 180;
int n, mod, m, q_n;
map<int, int> M;
int a[N], cnt[N], fib[N], bel[N], ans[N], RM[N];
struct node {
node *ch[2];
int siz, sum[2];
} * root;
pair<int, pair<int, int> > pls(const node *a, const node *b) {
pair<int, pair<int, int> > ret;
if (!b) {
ret = make_pair(a->siz, make_pair(a->sum[0], a->sum[1]));
return ret;
}
if (!a || !a->siz) {
ret = make_pair(b->siz, make_pair(b->sum[0], b->sum[1]));
return ret;
}
ret.first = a->siz + b->siz;
ret.second.first =
a->sum[0] + fib[a->siz] * b->sum[1] + fib[a->siz - 1] * b->sum[0];
ret.second.second =
a->sum[1] + fib[a->siz + 1] * b->sum[1] + fib[a->siz] * b->sum[0];
return ret;
}
void build(node *&cur = root, int l = 0, int r = m) {
cur = new node;
cur->ch[0] = cur->ch[1] = 0;
cur->siz = 0;
cur->sum[0] = cur->sum[1] = 0;
if (l == r) return;
int mid = l + r >> 1;
build(cur->ch[0], l, mid);
build(cur->ch[1], mid + 1, r);
return;
}
void modify(int i, int x, node *&cur = root, int l = 0, int r = m) {
if (l == r) {
if (x) {
cur->siz = 1;
cur->sum[0] = 0;
cur->sum[1] = RM[i] % mod;
return;
}
cur->siz = 0;
cur->sum[0] = cur->sum[1] = 0;
return;
}
int mid = l + r >> 1;
if (i <= mid)
modify(i, x, cur->ch[0], l, mid);
else
modify(i, x, cur->ch[1], mid + 1, r);
auto t = pls(cur->ch[0], cur->ch[1]);
cur->siz = t.first;
cur->sum[0] = t.second.first % mod;
cur->sum[1] = t.second.second % mod;
return;
}
struct query {
int l, r, id;
void in(int i) {
scf(l, r);
id = i;
}
bool operator<(const query &a) const {
return bel[l] == bel[a.l] ? ((bel[l] & 1) ? r > a.r : r < a.r)
: bel[l] < bel[a.l];
}
} q[N];
void TZL() {
scf(n, mod);
for (int i = (1); i <= (n); ++i) scf(a[i]), M[a[i]];
fib[0] = 0;
fib[1] = 1;
for (int i = (2); i <= (n + 10); ++i) {
fib[i] = fib[i - 1] + fib[i - 2];
if (fib[i] >= mod) fib[i] -= mod;
}
for (int i = (1); i <= (n); ++i) bel[i] = i / B;
for (auto it = M.begin(); it != M.end(); it++)
it->second = (++m), RM[m] = it->first;
M[0] = 0;
build();
return;
}
void ins(int x) {
if (!cnt[x]++) modify(x, 1);
}
void del(int x) {
if (!--cnt[x]) modify(x, 0);
}
void RANK1() {
scf(q_n);
for (int i = (1); i <= (q_n); ++i) q[i].in(i);
sort(q + 1, q + q_n + 1);
int l, r;
l = r = 0;
for (int i = (1); i <= (q_n); ++i) {
int &lb = q[i].l, &rb = q[i].r;
while (r < rb) ins(M[a[++r]]);
while (r > rb) del(M[a[r--]]);
while (l < lb) del(M[a[l++]]);
while (l > lb) ins(M[a[--l]]);
ans[q[i].id] = root->sum[1];
}
for (int i = (1); i <= (q_n); ++i) printf("%d\n", ans[i]);
return;
}
int main() {
TZL();
RANK1();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1e9 + 7;
const long long linf = 1ll << 60;
const double dinf = 1e60;
template <typename T>
inline void scf(T &x) {
bool f = 0;
x = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (f) x = -x;
return;
}
template <typename T1, typename T2>
void scf(T1 &x, T2 &y) {
scf(x);
return scf(y);
}
template <typename T1, typename T2, typename T3>
void scf(T1 &x, T2 &y, T3 &z) {
scf(x);
scf(y);
return scf(z);
}
template <typename T1, typename T2, typename T3, typename T4>
void scf(T1 &x, T2 &y, T3 &z, T4 &w) {
scf(x);
scf(y);
scf(z);
return scf(w);
}
inline char mygetchar() {
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
template <typename T>
void chkmax(T &x, const T &y) {
if (y > x) x = y;
return;
}
template <typename T>
void chkmin(T &x, const T &y) {
if (y < x) x = y;
return;
}
const int N = 3e4 + 100;
int n, mod, q_n;
int fib[N];
pair<int, int> a[N];
int l[N], r[N], lst[N];
int cnt[N];
long long ans[N];
void TZL() {
scf(n, mod);
for (int i = (1); i <= (n); ++i) scf(a[i].first), a[i].second = i;
sort(a + 1, a + n + 1);
scf(q_n);
for (int i = (1); i <= (q_n); ++i) scf(l[i], r[i]), lst[i] = -1;
fib[0] = 0;
fib[1] = fib[2] = 1;
for (int i = (3); i <= (n); ++i) {
fib[i] = fib[i - 1] + fib[i - 2];
if (fib[i] >= mod) fib[i] -= mod;
}
return;
}
void RANK1() {
auto t = a;
int x, i;
for (int _ = (1); _ <= (n); ++_) {
t++;
x = t->first, i = t->second;
for (int j = (1); j <= (q_n); ++j)
if (l[j] <= i && i <= r[j] && x != lst[j])
ans[j] += 1ll * x * fib[(++cnt[j])], lst[j] = x;
}
for (int i = (1); i <= (q_n); ++i) printf("%d\n", (int)(ans[i] % mod));
return;
}
int main() {
TZL();
RANK1();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e4 + 5;
int f[maxn], l[maxn], r[maxn], ans[maxn], num[maxn], last[maxn];
bool used[maxn];
pair<int, int> p[maxn];
int main() {
int n, mod;
while (~scanf("%d%d", &n, &mod)) {
f[0] = f[1] = 1;
for (int i = 2; i < maxn; ++i) f[i] = (f[i - 1] + f[i - 2]) % mod;
for (int i = 1; i <= n; ++i) {
scanf("%d", &p[i].first);
p[i].second = i;
}
sort(p + 1, p + n + 1);
int q;
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
scanf("%d%d", l + i, r + i);
ans[i] = 0;
num[i] = 0;
last[i] = -1;
}
for (int i = 1; i <= n; ++i) {
int x = p[i].first % mod;
for (int j = 0; j < q; ++j) {
if (last[j] == p[i].first || l[j] > p[i].second || r[j] < p[i].second)
continue;
ans[j] = (ans[j] + x * f[num[j]++]) % mod;
last[j] = p[i].first;
}
}
for (int i = 0; i < q; ++i) printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[30005];
int ans[30005], step[30005], f[30005], l[30005], r[30004], last[30005];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a + 1, a + 1 + n);
f[0] = 1;
f[1] = 1;
for (int i = 2; i <= n; i++) f[i] = (f[i - 1] + f[i - 2]) % m;
int q;
cin >> q;
for (int i = 1; i <= q; i++) {
cin >> l[i] >> r[i];
last[i] = -1;
}
for (int i = 1; i <= n; i++) {
int d = a[i].first % m;
for (int j = 1; j <= q; j++) {
if (a[i].second < l[j] || a[i].second > r[j]) continue;
if (a[i].first == last[j]) continue;
ans[j] = (ans[j] + f[step[j]++] * d) % m;
last[j] = a[i].first;
}
}
for (int i = 1; i <= q; i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1e9 + 7;
const long long linf = 1ll << 60;
const double dinf = 1e60;
template <typename T>
inline void scf(T &x) {
bool f = 0;
x = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (f) x = -x;
return;
}
template <typename T1, typename T2>
void scf(T1 &x, T2 &y) {
scf(x);
return scf(y);
}
template <typename T1, typename T2, typename T3>
void scf(T1 &x, T2 &y, T3 &z) {
scf(x);
scf(y);
return scf(z);
}
template <typename T1, typename T2, typename T3, typename T4>
void scf(T1 &x, T2 &y, T3 &z, T4 &w) {
scf(x);
scf(y);
scf(z);
return scf(w);
}
inline char mygetchar() {
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
template <typename T>
void chkmax(T &x, const T &y) {
if (y > x) x = y;
return;
}
template <typename T>
void chkmin(T &x, const T &y) {
if (y < x) x = y;
return;
}
const int N = 3e4 + 100;
int n, mod, q_n;
int fib[N];
pair<int, int> a[N];
int l[N], r[N], lst[N];
int cnt[N];
long long ans[N];
void TZL() {
scf(n, mod);
for (int i = (1); i <= (n); ++i) scf(a[i].first), a[i].second = i;
sort(a + 1, a + n + 1);
scf(q_n);
for (int i = (1); i <= (q_n); ++i) scf(l[i], r[i]), lst[i] = -1;
fib[0] = 0;
fib[1] = fib[2] = 1;
for (int i = (3); i <= (n); ++i) {
fib[i] = fib[i - 1] + fib[i - 2];
if (fib[i] >= mod) fib[i] -= mod;
}
return;
}
void RANK1() {
for (int _ = (1); _ <= (n); ++_) {
int x = a[_].first, i = a[_].second;
for (int j = (1); j <= (q_n); ++j)
if (l[j] <= i && i <= r[j] && x != lst[j])
ans[j] += 1ll * x * fib[(++cnt[j])], lst[j] = x;
}
for (int i = (1); i <= (q_n); ++i) printf("%d\n", (int)(ans[i] % mod));
return;
}
int main() {
TZL();
RANK1();
return 0;
}
|
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
struct LazyContext {
LazyContext() {}
void reset() {}
void operator+=(LazyContext o) {}
};
int mod;
struct modBase {
modBase(int v = 0) : val(v) {}
int val;
void operator+=(modBase o) { *this = *this + o; }
void operator-=(modBase o) { *this = *this - o; }
void operator*=(modBase o) { *this = *this * o; }
modBase operator*(modBase o) { return (int)(val * o.val % mod); }
modBase operator+(modBase o) {
return val + o.val >= mod ? val + o.val - mod : val + o.val;
}
modBase operator-(modBase o) {
return val - o.val < 0 ? val - o.val + mod : val - o.val;
}
};
struct Info {
Info(int x) {
val = x;
recalc();
}
void recalc() {
if (freq <= 0) {
a[0] = 1, a[1] = 0;
b[0] = b[1] = 0;
} else {
a[0] = 0, a[1] = 1;
b[0] = 0, b[1] = val % mod;
}
}
Info(Info l, Info r) {
a[0] = l.a[0] * r.a[0] + l.a[1] * r.a[1];
a[1] = l.a[1] * r.a[0] + l.a[0] * r.a[1] + l.a[1] * r.a[1];
b[0] = l.a[0] * r.b[0] + l.a[1] * r.b[1] + l.b[0];
b[1] = l.a[1] * r.b[0] + l.a[0] * r.b[1] + l.a[1] * r.b[1] + l.b[1];
}
void apply(LazyContext lazy, int size) {}
void rotate() {}
bool operator<(const Info& o) const { return val < o.val; }
modBase a[2];
modBase b[2];
int freq = 0;
int val;
};
template <class i_t, class lazy_cont>
struct SplayTree {
struct Node {
Node *p = NULL, *left = NULL, *right = NULL;
int size = 1;
bool flip = false;
i_t base, info;
lazy_cont lazy;
Node(i_t v) : base(v), info(v) {}
~Node() {
if (left) delete left;
if (right) delete right;
}
void applyLazy(lazy_cont l) {
info.apply(l, size);
base.apply(l, 1);
lazy += l;
}
void fix() {
push(), info = base;
size = 1;
if (left)
info = i_t(left->info, info), size += left->size, left->p = this;
if (right)
info = i_t(info, right->info), size += right->size, right->p = this;
}
Node* splay() {
pull();
while (p) {
Node *y = p, *z = p->p;
bool t1 = (y->left != this);
bool t2 = z && (z->left != y) == t1;
if (t2) y->rotate(t1);
rotate(t1);
if (z && !t2) rotate(!t1);
}
fix();
return this;
}
void push() {
if (flip) {
std::swap(left, right);
if (left) left->flip = !left->flip, left->info.rotate();
if (right) right->flip = !right->flip, right->info.rotate();
flip = false;
}
if (left) left->applyLazy(lazy);
if (right) right->applyLazy(lazy);
lazy.reset();
}
void pull() {
if (p) {
p->pull();
}
push();
}
void rotate(bool leftRotate) {
Node *y = p, *z = p->p, *&w = leftRotate ? left : right;
if (z) (z->right == y ? z->right : z->left) = this;
if (w) w->p = y;
(leftRotate ? y->right : y->left) = w;
w = y;
p = z;
y->p = this;
y->fix();
}
};
Node* root;
SplayTree(Node* r = NULL) : root(r) {}
Node* lower_bound(i_t val) {
return search(val, [](const i_t& a, const i_t& b) { return !(b < a); });
}
Node* upper_bound(i_t val) {
return search(val, [](const i_t& a, const i_t& b) { return a < b; });
}
Node* splayFirst() { return expose(1); }
Node* splayLast() { return expose(1e9); }
Node* expose(int k) {
Node* cur = root;
if (!cur) return NULL;
k = std::min(k, cur->size);
k = std::max(k, 1);
while (cur) {
cur->push();
if (cur->left) {
if (cur->left->size >= k) {
cur = cur->left;
continue;
} else {
k -= cur->left->size;
}
}
if (k == 1) {
break;
}
k--;
cur = cur->right;
}
assert(cur);
return root = cur->splay();
}
template <class F>
Node* search(i_t val, F f) {
Node *ans = NULL, *cur = root, *last = NULL;
while (cur) {
cur->push();
last = cur;
if (f(val, cur->base)) {
ans = cur;
cur = cur->left;
} else {
cur = cur->right;
}
}
root = last->splay();
if (ans) root = ans->splay();
return ans;
}
void insert(i_t t) { insert(new Node(t)); }
void insert(Node* node) {
if (!root) {
root = node;
return;
}
Node* tree = root;
while (1) {
tree->push();
Node*& w = node->base < tree->base ? tree->left : tree->right;
if (w) {
tree = w;
} else {
w = node;
tree->fix();
break;
}
}
root = node->splay();
}
void erase(Node* node) {
node->pull();
if (node == root) {
if (node->left) node->left->p = NULL;
if (node->right) node->right->p = NULL;
*this = SplayTree(node->left) + SplayTree(node->right);
} else {
assert(node->p);
Node*& w = node->p->left == node ? node->p->left : node->p->right;
if (!node->left || !node->right) {
w = node->left ? node->left : node->right;
} else {
node->left->p = node->right->p = NULL;
w = (SplayTree(node->left) + SplayTree(node->right)).root;
}
node->p->fix();
root = node->p->splay();
}
}
SplayTree operator+(SplayTree o) {
if (!root) return o;
if (!o.root) return *this;
splayLast();
assert(!root->right && !o.root->p);
root->right = o.root;
root->fix();
return SplayTree(root);
}
};
inline int64_t hilbertOrder(int x, int y, int pow, int rotate) {
if (pow == 0) {
return 0;
}
int hpow = 1 << (pow - 1);
int seg = (x < hpow) ? ((y < hpow) ? 0 : 3) : ((y < hpow) ? 1 : 2);
seg = (seg + rotate) & 3;
const int rotateDelta[4] = {3, 0, 0, 1};
int nx = x & (x ^ hpow), ny = y & (y ^ hpow);
int nrot = (rotate + rotateDelta[seg]) & 3;
int64_t subSquareSize = int64_t(1) << (2 * pow - 2);
int64_t ans = seg * subSquareSize;
int64_t add = hilbertOrder(nx, ny, pow - 1, nrot);
ans += (seg == 1 || seg == 2) ? add : (subSquareSize - add - 1);
return ans;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int n, m;
std::cin >> n >> mod;
std::map<int, SplayTree<Info, LazyContext>::Node*> st;
SplayTree<Info, LazyContext> tree;
struct Query {
int l, r;
int id;
void read() {
std::cin >> l >> r;
l--;
}
bool operator<(const Query& o) const {
return hilbertOrder(l, r, 21, 0) < hilbertOrder(o.l, o.r, 21, 0);
}
};
std::vector<int> a(n);
for (int i = 0; i < n; i++) {
std::cin >> a[i];
if (!st.count(a[i])) {
tree.insert(Info(a[i]));
st[a[i]] = tree.root;
assert(tree.root->base.val == a[i]);
}
}
std::cin >> m;
std::vector<Query> qries(m);
for (int i = 0; i < m; i++) {
qries[i].read();
qries[i].id = i;
}
std::sort(qries.begin(), qries.end());
std::vector<int> ans(m, -1);
int l = 0, r = 0;
auto add = [&](int x, int f) {
auto node = st[x];
node->base.freq += f;
if (node->base.freq == f || node->base.freq == 0) {
tree.root = node->splay();
assert(node && node->base.val == x && tree.root == node);
node->base.recalc();
node->fix();
}
};
for (auto qry : qries) {
while (l > qry.l) add(a[--l], 1);
while (r < qry.r) add(a[r++], 1);
while (r > qry.r) add(a[--r], -1);
while (l < qry.l) add(a[l++], -1);
ans[qry.id] = tree.root->info.b[1].val;
}
for (int i = 0; i < m; i++) {
std::cout << ans[i] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 30000 + 5;
const int K = 175;
const int T = N / K + 5;
int n, m, q;
int a[N], ind[N], fib[N], ans[N], cnt[N];
int X[N], Y[N];
vector<int> qu[T];
vector<int> vs;
int f12[1 << 16], f23[1 << 16], t[1 << 16];
inline int add(int x, int y) { return x + y >= m ? x + y - m : x + y; }
inline int mul(int x, int y) { return x * y % m; }
void up(int x) {
while (x > 1) {
x >>= 1;
t[x] = t[x + x] + t[x + x + 1];
int c = t[x + x];
if (!c) {
f12[x] = f12[x + x + 1];
f23[x] = f23[x + x + 1];
continue;
}
f12[x] = add(f12[x + x], add(mul(f12[x + x + 1], fib[c - 1]),
mul(f23[x + x + 1], fib[c])));
f23[x] = add(f23[x + x], add(mul(f12[x + x + 1], fib[c]),
mul(f23[x + x + 1], fib[c + 1])));
}
}
void add(int x) {
if (cnt[x]++ == 0) {
x += 1 << 15;
t[x] = 1;
f12[x] = f23[x] = vs[x - (1 << 15) - 1] % m;
up(x);
}
}
void del(int x) {
if (--cnt[x] == 0) {
x += 1 << 15;
t[x] = 0;
f12[x] = f23[x] = 0;
up(x);
}
}
int main() {
scanf("%d %d", &n, &m);
fib[1] = 1;
for (int i = 2; i < N; i++) fib[i] = add(fib[i - 1], fib[i - 2]);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
vs.push_back(a[i]);
}
sort(vs.begin(), vs.end());
vs.resize(unique(vs.begin(), vs.end()) - vs.begin());
for (int i = 1; i <= n; i++) {
ind[i] = lower_bound(vs.begin(), vs.end(), a[i]) - vs.begin() + 1;
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d %d", X + i, Y + i);
qu[(X[i] - 1) / K].push_back(i);
}
for (int it = 0; it < T; it++) {
if (qu[it].empty()) continue;
memset(cnt, 0, sizeof(cnt));
memset(t, 0, sizeof(t));
memset(f12, 0, sizeof(f12));
memset(f23, 0, sizeof(f23));
sort(qu[it].begin(), qu[it].end(),
[&](int x, int y) { return Y[x] < Y[y]; });
int last = min((it + 1) * K, n);
int R = last;
for (auto id : qu[it]) {
int x = X[id];
int y = Y[id];
for (int i = R + 1; i <= y; i++) {
add(ind[i]);
R = i;
}
for (int i = x; i <= y and i <= last; i++) {
add(ind[i]);
}
ans[id] = f12[1];
for (int i = x; i <= y and i <= last; i++) {
del(ind[i]);
}
}
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int a[31000], b[31000], cnt, bel[31000];
int ans[31000], f[31000];
long long v1[31000 << 2], v2[31000 << 2];
int size[31000 << 2], num[31000];
struct node {
int l, r, pos;
friend bool operator<(node r1, node r2) {
if (bel[r1.l] == bel[r2.l]) return r1.r < r2.r;
return bel[r1.l] < bel[r2.l];
}
} p[31000];
long long cal(long long x, long long y, int pos) {
long long t1, t2;
if (pos == 1)
t1 = 1, t2 = 0;
else
t1 = f[pos - 2], t2 = f[pos - 1];
return t1 * x + t2 * y;
}
void pushup(int now, int l, int r) {
size[now] = size[now << 1] + size[now << 1 | 1];
v1[now] = (v1[now << 1] +
cal(v1[now << 1 | 1], v2[now << 1 | 1], size[now << 1] + 1)) %
m;
v2[now] = (v2[now << 1] +
cal(v1[now << 1 | 1], v2[now << 1 | 1], size[now << 1] + 2)) %
m;
}
void update(int l, int r, int now, int pos, int type) {
if (l == r) {
size[now] += type;
if (type == -1)
v1[now] = v2[now] = 0;
else
v1[now] = v2[now] = b[pos];
return;
}
int mid = (l + r) >> 1;
if (mid >= pos)
update(l, mid, now << 1, pos, type);
else
update(mid + 1, r, now << 1 | 1, pos, type);
pushup(now, l, r);
}
void update(int x, int y) {
int t = lower_bound(b + 1, b + 1 + cnt, a[x]) - b;
if (y == 1) {
num[t]++;
if (num[t] == 1) update(1, cnt, 1, t, y);
} else {
num[t]--;
if (num[t] == 0) update(1, cnt, 1, t, y);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), b[i] = a[i];
f[1] = 1;
for (int i = 2; i <= n; i++) f[i] = (f[i - 1] + f[i - 2]) % m;
sort(b + 1, b + 1 + n);
int len = ceil(sqrt(n));
for (int i = 1; i <= n; i++) bel[i] = (i - 1) / len + 1;
cnt = unique(b + 1, b + 1 + n) - b - 1;
scanf("%d", &q);
for (int i = 1; i <= q; i++) scanf("%d%d", &p[i].l, &p[i].r), p[i].pos = i;
sort(p + 1, p + 1 + q);
int l = 1, r = 0;
for (int i = 1; i <= q; i++) {
while (l < p[i].l) update(l, -1), l++;
while (l > p[i].l) l--, update(l, 1);
while (r > p[i].r) update(r, -1), r--;
while (r < p[i].r) r++, update(r, 1);
ans[p[i].pos] = v1[1];
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e4 + 50;
int n, m, q, x;
struct node {
int val, id;
bool operator<(const node &o) const { return val < o.val; }
} a[N];
int Fib[N], l[N], r[N], Max[N], Now[N];
long long Ans[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i].val);
a[i].id = i;
}
sort(a + 1, a + n + 1);
Fib[1] = Fib[2] = 1;
for (int i = 3; i <= n; ++i) Fib[i] = (Fib[i - 1] + Fib[i - 2]) % m;
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
scanf("%d%d", &l[i], &r[i]);
Max[i] = -1;
}
for (int i = 1; i <= n; ++i) {
x = a[i].val % m;
for (int j = 1; j <= q; ++j)
if (a[i].id >= l[j] && a[i].id <= r[j] && a[i].val != Max[j]) {
Max[j] = a[i].val;
Ans[j] += Fib[++Now[j]] * x;
}
}
for (int i = 1; i <= q; i++) printf("%lld\n", Ans[i] % m);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
int seg[2000001][2], lzy[2000001], fib[200001], M;
void update(int idx, int s, int e) {
if (s == e) {
lzy[idx] = 0;
return;
}
int v1 = (seg[idx * 2 + 1][0] * fib[lzy[idx] - 1] +
seg[idx * 2 + 1][1] * fib[lzy[idx]]) %
M;
int v2 = (seg[idx * 2 + 1][0] * fib[lzy[idx]] +
seg[idx * 2 + 1][1] * fib[lzy[idx] + 1]) %
M;
seg[idx * 2 + 1][0] = v1;
seg[idx * 2 + 1][1] = v2;
lzy[idx * 2 + 1] += lzy[idx];
v1 = (seg[idx * 2 + 2][0] * fib[lzy[idx] - 1] +
seg[idx * 2 + 2][1] * fib[lzy[idx]]) %
M;
v2 = (seg[idx * 2 + 2][0] * fib[lzy[idx]] +
seg[idx * 2 + 2][1] * fib[lzy[idx] + 1]) %
M;
seg[idx * 2 + 2][0] = v1;
seg[idx * 2 + 2][1] = v2;
lzy[idx * 2 + 2] += lzy[idx];
lzy[idx] = 0;
}
void insert1(int idx, int s, int e, int p, int v1, int v2) {
if (lzy[idx]) {
update(idx, s, e);
}
if (s == e) {
seg[idx][0] = v1;
seg[idx][1] = v2;
return;
}
int mid = (s + e) / 2;
if (p <= mid)
insert1(idx * 2 + 1, s, mid, p, v1, v2);
else
insert1(idx * 2 + 2, mid + 1, e, p, v1, v2);
for (int i = (0); i < (2); ++i)
seg[idx][i] = (seg[idx * 2 + 1][i] + seg[idx * 2 + 2][i]) % M;
}
void insert2(int idx, int s, int e, int st, int ed) {
if (st > ed) return;
if (lzy[idx]) {
update(idx, s, e);
}
if (s == st && e == ed) {
int v = (seg[idx][0] + seg[idx][1]) % M;
seg[idx][0] = seg[idx][1];
seg[idx][1] = v;
lzy[idx]++;
return;
}
int mid = (s + e) / 2;
if (ed <= mid)
insert2(idx * 2 + 1, s, mid, st, ed);
else if (st > mid)
insert2(idx * 2 + 2, mid + 1, e, st, ed);
else {
insert2(idx * 2 + 1, s, mid, st, mid);
insert2(idx * 2 + 2, mid + 1, e, mid + 1, ed);
}
for (int i = (0); i < (2); ++i)
seg[idx][i] = (seg[idx * 2 + 1][i] + seg[idx * 2 + 2][i]) % M;
}
pair<int, int> query1(int idx, int s, int e, int st, int ed) {
if (lzy[idx]) {
update(idx, s, e);
}
if (st > ed) return make_pair(0, 0);
if (s == st && e == ed) return make_pair(seg[idx][0], seg[idx][1]);
int mid = (s + e) / 2;
if (ed <= mid)
return query1(idx * 2 + 1, s, mid, st, ed);
else if (st > mid)
return query1(idx * 2 + 2, mid + 1, e, st, ed);
else {
pair<int, int> pl = query1(idx * 2 + 1, s, mid, st, mid);
pair<int, int> pr = query1(idx * 2 + 2, mid + 1, e, mid + 1, ed);
return make_pair((pl.first + pr.first) % M, (pl.second + pr.second) % M);
}
}
int seg2[2000001];
void insert(int idx, int s, int e, int p) {
if (s == e) {
seg2[idx]++;
return;
}
int mid = (s + e) / 2;
if (p <= mid)
insert(idx * 2 + 1, s, mid, p);
else
insert(idx * 2 + 2, mid + 1, e, p);
seg2[idx]++;
}
int query(int idx, int s, int e, int st, int ed) {
if (st > ed) return 0;
if (s == st && e == ed) return seg2[idx];
int mid = (s + e) / 2;
if (ed <= mid)
return query(idx * 2 + 1, s, mid, st, ed);
else if (st > mid)
return query(idx * 2 + 2, mid + 1, e, st, ed);
else {
return query(idx * 2 + 1, s, mid, st, mid) +
query(idx * 2 + 2, mid + 1, e, mid + 1, ed);
}
}
pair<int, int> pp[300001];
vector<pair<int, int> > vc[300001];
int res[300001];
map<int, int> mm;
int ar[300001], val[300001];
int on[300001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n >> M;
for (int i = (0); i < (n); ++i) {
cin >> ar[i];
mm[ar[i]] = 1;
}
int cnt = 0;
for (auto &v : mm) {
v.second = ++cnt;
val[v.second] = v.first % M;
}
for (int i = (0); i < (n); ++i) {
ar[i] = mm[ar[i]];
}
fib[0] = 0;
fib[1] = 1 % M;
for (int i = 2; i <= 200000; i++) fib[i] = (fib[i - 1] + fib[i - 2]) % M;
int SZ = 230;
int q;
cin >> q;
for (int i = (0); i < (q); ++i) {
int l, r;
cin >> l >> r;
l--;
r--;
pp[i] = make_pair(l, r);
if ((l / SZ) == (r / SZ)) {
set<int> S;
for (int j = l; j <= r; j++) S.insert(ar[j]);
int cc = 0;
for (auto &v : S) {
res[i] = (res[i] + val[v] * fib[++cc]) % M;
}
continue;
}
vc[r].push_back(make_pair(l, i));
}
for (int i = 0; i < n; i += SZ) {
memset(on, 0, sizeof on);
memset(seg, 0, sizeof seg);
memset(seg2, 0, sizeof seg2);
for (int j = i + SZ; j < n; j++) {
if (on[ar[j]] == 0) {
on[ar[j]] = 1;
int pre = query(0, 1, cnt, 1, ar[j] - 1) + 1;
insert(0, 1, cnt, ar[j]);
insert1(0, 1, cnt, ar[j], (val[ar[j]] * fib[pre - 1]) % M,
(val[ar[j]] * fib[pre]) % M);
insert2(0, 1, cnt, ar[j] + 1, cnt);
}
for (int k = (0); k < (vc[j].size()); ++k) {
if (vc[j][k].first < i || vc[j][k].first >= i + SZ) continue;
set<int> S;
for (int l = i + SZ - 1; l >= vc[j][k].first; l--) {
if (on[ar[l]] || S.count(ar[l])) continue;
S.insert(ar[l]);
}
int cc = 0, pre = 0, tot = 0;
for (auto &v : S) {
pair<int, int> p = query1(0, 1, cnt, pre + 1, v);
int pcnt = query(0, 1, cnt, pre + 1, v);
int vv = (p.first * fib[cc] + p.second * fib[cc + 1]) % M;
pre = v;
tot += pcnt + 1;
cc++;
vv = (vv + val[v] * fib[tot]) % M;
res[vc[j][k].second] = (res[vc[j][k].second] + vv) % M;
}
pair<int, int> p = query1(0, 1, cnt, pre + 1, cnt);
int vv = (p.first * fib[cc] + p.second * fib[cc + 1]) % M;
res[vc[j][k].second] = (res[vc[j][k].second] + vv) % M;
}
}
}
for (int i = (0); i < (q); ++i) cout << res[i] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 30010;
pair<int, int> a[maxn];
int f[maxn], L[maxn], R[maxn], num[maxn], ans[maxn], lt[maxn];
int main() {
int N, M, P;
scanf("%d%d", &N, &P);
f[1] = 1;
f[2] = 1;
for (int i = 3; i <= N; i++) f[i] = (f[i - 1] + f[i - 2]) % P;
for (int i = 1; i <= N; i++)
scanf("%d", &a[i].first), a[i].first, a[i].second = i;
sort(a + 1, a + N + 1);
scanf("%d", &M);
for (int i = 1; i <= M; i++) {
scanf("%d%d", &L[i], &R[i]);
lt[i] = -1;
}
for (int i = 1; i <= N; i++) {
int d = a[i].first % P;
for (int j = 1; j <= M; j++) {
if (a[i].second > R[j] || a[i].second < L[j]) continue;
if (a[i].first == lt[j]) continue;
ans[j] = (ans[j] + f[++num[j]] * d) % P;
lt[j] = a[i].first;
}
}
for (int i = 1; i <= M; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int N = 30000;
const int M = 30000;
struct Input {
int mod;
int n, m;
int a[N];
int l[M], r[M];
bool read() {
if (!(cin >> n >> mod)) {
return 0;
}
for (int i = int(0); i < int(n); ++i) {
scanf("%d", &a[i]);
}
cin >> m;
for (int i = int(0); i < int(m); ++i) {
scanf("%d%d", &l[i], &r[i]);
--l[i];
}
return 1;
}
void init(const Input& input) { *this = input; }
};
struct Data : Input {
int ans[M];
void write() {
for (int i = int(0); i < int(m); ++i) {
cout << ans[i] << endl;
}
}
virtual void solve() {}
virtual void clear() { *this = Data(); }
};
struct Solution : Data {
static const int K = 13;
static const int D = N / K + 1;
int f[N + 10];
int p[N], rev[N];
int cnt[M];
int hv[M];
int msk[N + 1];
int mb[1 << K], bt[2][1 << K], v[2][1 << K][2];
void solve() {
f[0] = 1;
f[1] = 0;
for (int i = int(0); i < int(N + 8); ++i) {
f[i + 2] = (f[i] + f[i + 1]) % mod;
}
for (int i = int(0); i < int(n); ++i) {
p[i] = i;
}
sort(p, p + n, [&](int i, int j) { return a[i] < a[j]; });
;
for (int i = int(0); i < int(n); ++i) {
rev[p[i]] = i;
}
for (int i = int(0); i < int(1 << K); ++i) {
mb[i] = K;
while (mb[i] >= 0 && !(i & (1 << mb[i]))) {
--mb[i];
}
}
memset(ans, 0, sizeof ans);
memset(cnt, 0, sizeof cnt);
memset(hv, -1, sizeof hv);
for (int t = int(0); t < int(D); ++t) {
if (t * K >= n) {
break;
};
msk[0] = 0;
for (int i = int(0); i < int(n); ++i) {
msk[i + 1] = msk[i];
if (rev[i] >= t * K && rev[i] < (t + 1) * K) {
msk[i + 1] |= 1 << (rev[i] - t * K);
}
};
memset(v, 0, sizeof v);
memset(bt, 0, sizeof bt);
for (int w = int(0); w < int(2); ++w) {
for (int i = int(0); i < int(min(K, n - t * K)); ++i) {
for (int q = int(0); q < int(1 << i); ++q) {
if (i ? (a[p[t * K + i]] == a[p[t * K + i - 1]]) : w) {
if (i) {
v[w][q | (1 << i)][0] = v[w][q | (1 << (i - 1))][0];
v[w][q | (1 << i)][1] = v[w][q | (1 << (i - 1))][1];
bt[w][q | (1 << i)] = bt[w][q | (1 << (i - 1))];
} else {
v[w][q | (1 << i)][0] = v[w][q][0];
v[w][q | (1 << i)][1] = v[w][q][1];
bt[w][q | (1 << i)] = bt[w][q];
}
} else {
v[w][q | (1 << i)][0] =
(v[w][q][0] + f[bt[w][q]] * (a[p[t * K + i]] % mod)) % mod;
v[w][q | (1 << i)][1] =
(v[w][q][1] + f[bt[w][q] + 1] * (a[p[t * K + i]] % mod)) %
mod;
bt[w][q | (1 << i)] = bt[w][q] + 1;
}
}
}
}
for (int i = int(0); i < int(m); ++i) {
int ttt = (hv[i] == -1) ? 0 : (a[p[hv[i]]] == a[p[t * K]]);
int mmm = msk[r[i]] & ~msk[l[i]];
ans[i] = (ans[i] + v[ttt][mmm][0] * f[cnt[i] + 2] +
v[ttt][mmm][1] * f[cnt[i] + 3]) %
mod;
;
;
;
cnt[i] += bt[ttt][mmm];
if (mb[mmm] != -1) {
hv[i] = t * K + mb[mmm];
}
}
}
}
void clear() { *this = Solution(); }
};
Solution sol;
int main() {
;
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[30005], tmp[30005];
int B;
struct query {
int l, r, id;
bool operator<(const query &x) const {
if (l / B != x.l / B) return l < x.l;
return (l / B) & 1 ? r < x.r : r > x.r;
}
} q[30005];
struct matrix {
int a, b, c, d;
void set() {
a = d = 1;
b = c = 0;
}
void operator*(const matrix &w) {
matrix s;
s.a = (a * w.a + b * w.c) % m;
s.b = (a * w.b + b * w.d) % m;
s.c = (c * w.a + d * w.c) % m;
s.d = (c * w.b + d * w.d) % m;
a = s.a;
b = s.b;
c = s.c;
d = s.d;
}
} zy, nzy, ad[30005 << 2], sum[30005 << 2];
int f[30005], vis[30005 << 2];
int ss[30005];
int lb(int x) { return x & (-x); }
void adds(int x, int y) {
for (; x <= n; x += lb(x)) ss[x] += y;
}
int ask(int x) {
int ans = 0;
for (; x; x -= lb(x)) ans += ss[x];
return ans;
}
void build(int k, int l, int r) {
ad[k].set();
if (l == r) return;
int mid = l + r >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
}
void add(int k, const matrix &w) {
ad[k] * w;
sum[k] * w;
vis[k] = 1;
}
void pd(int k) {
if (!vis[k]) return;
add(k << 1, ad[k]);
add(k << 1 | 1, ad[k]);
ad[k].set();
vis[k] = 0;
}
void update(int k) {
sum[k].a = (sum[k << 1].a + sum[k << 1 | 1].a) % m;
sum[k].b = (sum[k << 1].b + sum[k << 1 | 1].b) % m;
}
void change(int k, int l, int r, int a, int x, int y, int op) {
sum[k].a += op * x + m;
sum[k].b += op * y + m;
sum[k].a %= m;
sum[k].b %= m;
if (l == r) return;
pd(k);
int mid = l + r >> 1;
if (a <= mid)
change(k << 1, l, mid, a, x, y, op);
else
change(k << 1 | 1, mid + 1, r, a, x, y, op);
}
void change(int k, int l, int r, int x, int y, const matrix &a) {
if (x > y) return;
if (x <= l && r <= y) return add(k, a);
pd(k);
int mid = l + r >> 1;
if (x <= mid) change(k << 1, l, mid, x, y, a);
if (mid < y) change(k << 1 | 1, mid + 1, r, x, y, a);
update(k);
}
int t[30005];
void add(int x) {
t[a[x]]++;
if (t[a[x]] == 1) {
adds(a[x], 1);
int s = ask(a[x]);
change(1, 1, n, a[x], f[s - 1] * tmp[a[x]] % m, f[s] * tmp[a[x]] % m, 1);
change(1, 1, n, a[x] + 1, n, zy);
}
}
void erase(int x) {
t[a[x]]--;
if (t[a[x]] == 0) {
change(1, 1, n, a[x] + 1, n, nzy);
int s = ask(a[x]);
change(1, 1, n, a[x], f[s - 1] * tmp[a[x]] % m, f[s] * tmp[a[x]] % m, -1);
adds(a[x], -1);
}
}
int res[30005];
signed main() {
zy.b = zy.c = zy.d = 1;
scanf("%d%d", &n, &m);
nzy.b = nzy.c = 1;
nzy.a = m - 1;
f[1] = 1;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), tmp[i] = a[i];
for (int i = 2; i <= n; i++) f[i] = (f[i - 1] + f[i - 2]) % m;
sort(tmp + 1, tmp + n + 1);
int sss = unique(tmp + 1, tmp + n + 1) - tmp - 1;
for (int i = 1; i <= n; i++)
a[i] = lower_bound(tmp + 1, tmp + sss + 1, a[i]) - tmp;
for (int i = 1; i <= n; i++) tmp[i] %= m;
int Q;
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
scanf("%d%d", &q[i].l, &q[i].r);
q[i].id = i;
}
B = sqrt(n);
sort(q + 1, q + Q + 1);
int l = 1, r = 0;
build(1, 1, n);
for (int i = 1; i <= Q; i++) {
while (r < q[i].r) add(++r);
while (l > q[i].l) add(--l);
while (r > q[i].r) erase(r--);
while (l < q[i].l) erase(l++);
res[q[i].id] = sum[1].b;
}
for (int i = 1; i <= Q; i++) cout << res[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct ai {
int a, num;
bool operator<(const ai &B) const { return a < B.a; }
} a[30001];
int n, m, q, top;
int num[30001], l[30001], r[30001], la[30001];
int fi[30001];
int ans[30001];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].a);
a[i].num = i;
}
sort(a + 1, a + 1 + n);
fi[1] = 1;
for (int i = 2; i <= n; i++) fi[i] = (fi[i - 1] + fi[i - 2]) % m;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d%d", &l[i], &r[i]);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < q; j++) {
if (a[i].num < l[j] || a[i].num > r[j] || a[i].a == la[j]) continue;
num[j]++;
ans[j] = (ans[j] + (a[i].a % m) * (fi[num[j]])) % m;
la[j] = a[i].a;
}
}
for (int i = 0; i < q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int F[30030];
int n;
int mod;
int a[30030], id[30030];
int nxt[30030];
bool cmp(int i, int j) { return a[i] < a[j]; }
int m;
struct pnt {
int l, r, i;
pnt(int l = 0, int r = 0, int i = 0) : l(l), r(r), i(i){};
} q[30030];
bool operator<(pnt a, pnt b) { return b.l != a.l ? a.l < b.l : a.r < b.r; }
int answer[30030];
int calc(int l, int r) {
int s = 0, m = 0;
for (int j, i = 1; i <= n; i++) {
j = id[i];
if (j >= l && j <= r) {
s = (s + F[++m] * a[j]) % mod;
i = nxt[i];
}
}
return s;
}
int main() {
scanf("%d %d", &n, &mod);
F[1] = F[2] = 1 % mod;
for (int i = 3; i <= n; i++) {
F[i] = (F[i - 1] + F[i - 2]) % mod;
}
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
id[i] = i;
}
sort(id + 1, id + n + 1, cmp);
nxt[n] = n;
for (int j = n - 1; j >= 1; j--) {
if (a[id[j]] == a[id[j + 1]]) {
nxt[j] = nxt[j + 1];
} else {
nxt[j] = j;
}
}
for (int j = 1; j <= n; j++) {
a[j] %= mod;
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &q[i].l, &q[i].r);
q[i].i = i;
}
sort(q + 1, q + m + 1);
for (int i = 1; i <= m; i++) {
if (i > 1 && q[i].l == q[i - 1].l && q[i].r == q[i - 1].r) {
answer[q[i].i] = answer[q[i - 1].i];
} else {
answer[q[i].i] = calc(q[i].l, q[i].r);
}
}
for (int i = 1; i <= m; i++) {
printf("%d\n", answer[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-11;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 62;
const int mods = 1e9 + 7;
const int MAXN = 30050;
const int INF = 0x3f3f3f3f;
inline int read() {
int f = 1, x = 0;
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 x * f;
}
using namespace std;
struct qnode {
int x, id;
bool operator<(const qnode &a) const { return x < a.x; }
} a[MAXN];
int Fib[MAXN], l[MAXN], r[MAXN], smax[MAXN], num[MAXN];
long long Ans[MAXN];
int main() {
int n = read(), mods = read();
for (int i = 1; i <= n; i++) a[i].x = read(), a[i].id = i;
sort(a + 1, a + n + 1);
int m = read();
for (int i = 1; i <= m; i++) l[i] = read(), r[i] = read(), smax[i] = -1;
Fib[1] = Fib[2] = 1;
for (int i = 3; i <= n; i++) Fib[i] = (Fib[i - 1] + Fib[i - 2]) % mods;
for (int i = 1; i <= n; i++) {
int x = a[i].x % mods;
for (int j = 1; j <= m; j++)
if (a[i].id >= l[j] && a[i].id <= r[j] && a[i].x != smax[j])
smax[j] = a[i].x, num[j]++, Ans[j] += Fib[num[j]] * x;
}
for (int i = 1; i <= m; i++) printf("%lld\n", Ans[i] % mods);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 30010;
const int M = 1e7 + 1000;
int f[N], n, m, k;
struct pp {
int id, v;
} p[N];
int l[N], r[N], cnt[N], maxx[N];
long long ans[N];
inline int read() {
char c = getchar();
int a = 0;
int aa = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') aa = -1;
for (; c >= '0' && c <= '9'; c = getchar()) a = (a * 10) + c - 48;
return aa * a;
}
bool cmp(pp a, pp b) { return a.v < b.v; }
int main() {
n = read();
m = read();
f[0] = 0;
f[1] = 1;
for (int i = 2; i <= 30000; i++) f[i] = (f[i - 1] + f[i - 2]) % m;
for (int i = 1; i <= n; i++) {
p[i].v = read();
p[i].id = i;
}
sort(p + 1, p + n + 1, cmp);
k = read();
for (int i = 1; i <= k; i++) {
l[i] = read();
r[i] = read();
maxx[i] = -1;
}
for (int i = 1; i <= n; i++) {
int x = p[i].v % m;
for (int j = 1; j <= k; j++)
if (p[i].id >= l[j] && p[i].id <= r[j] && p[i].v != maxx[j]) {
maxx[j] = p[i].v;
ans[j] += f[++cnt[j]] * x;
}
}
for (int i = 1; i <= k; i++) printf("%lld\n", ans[i] % m);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int N = 30000;
const int M = 30000;
struct Input {
int mod;
int n, m;
int a[N];
int l[M], r[M];
bool read() {
if (!(cin >> n >> mod)) {
return 0;
}
for (int i = int(0); i < int(n); ++i) {
scanf("%d", &a[i]);
}
cin >> m;
for (int i = int(0); i < int(m); ++i) {
scanf("%d%d", &l[i], &r[i]);
--l[i];
}
return 1;
}
void init(const Input& input) { *this = input; }
};
struct Data : Input {
int ans[M];
void write() {
for (int i = int(0); i < int(m); ++i) {
cout << ans[i] << endl;
}
}
virtual void solve() {}
virtual void clear() { *this = Data(); }
};
struct Solution : Data {
static const int K = 12;
static const int D = N / K + 1;
int f[N + 10];
int p[N], rev[N];
int cnt[M];
int hv[M];
int msk[N + 1];
int mb[1 << K], bt[2][1 << K], v[2][1 << K][2];
void solve() {
f[0] = 1;
f[1] = 0;
for (int i = int(0); i < int(N + 8); ++i) {
f[i + 2] = (f[i] + f[i + 1]) % mod;
}
for (int i = int(0); i < int(n); ++i) {
p[i] = i;
}
sort(p, p + n, [&](int i, int j) { return a[i] < a[j]; });
;
for (int i = int(0); i < int(n); ++i) {
rev[p[i]] = i;
}
for (int i = int(0); i < int(1 << K); ++i) {
mb[i] = K;
while (mb[i] >= 0 && !(i & (1 << mb[i]))) {
--mb[i];
}
}
memset(ans, 0, sizeof ans);
memset(cnt, 0, sizeof cnt);
memset(hv, -1, sizeof hv);
for (int t = int(0); t < int(D); ++t) {
if (t * K >= n) {
break;
};
msk[0] = 0;
for (int i = int(0); i < int(n); ++i) {
msk[i + 1] = msk[i];
if (rev[i] >= t * K && rev[i] < (t + 1) * K) {
msk[i + 1] |= 1 << (rev[i] - t * K);
}
};
memset(v, 0, sizeof v);
memset(bt, 0, sizeof bt);
for (int w = int(0); w < int(2); ++w) {
for (int i = int(0); i < int(min(K, n - t * K)); ++i) {
for (int q = int(0); q < int(1 << i); ++q) {
if (i ? (a[p[t * K + i]] == a[p[t * K + i - 1]]) : w) {
if (i) {
v[w][q | (1 << i)][0] = v[w][q | (1 << (i - 1))][0];
v[w][q | (1 << i)][1] = v[w][q | (1 << (i - 1))][1];
bt[w][q | (1 << i)] = bt[w][q | (1 << (i - 1))];
} else {
v[w][q | (1 << i)][0] = v[w][q][0];
v[w][q | (1 << i)][1] = v[w][q][1];
bt[w][q | (1 << i)] = bt[w][q];
}
} else {
v[w][q | (1 << i)][0] =
(v[w][q][0] + f[bt[w][q]] * (a[p[t * K + i]] % mod)) % mod;
v[w][q | (1 << i)][1] =
(v[w][q][1] + f[bt[w][q] + 1] * (a[p[t * K + i]] % mod)) %
mod;
bt[w][q | (1 << i)] = bt[w][q] + 1;
}
}
}
}
for (int i = int(0); i < int(m); ++i) {
int ttt = (hv[i] == -1) ? 0 : (a[p[hv[i]]] == a[p[t * K]]);
int mmm = msk[r[i]] & ~msk[l[i]];
ans[i] = (ans[i] + v[ttt][mmm][0] * f[cnt[i] + 2] +
v[ttt][mmm][1] * f[cnt[i] + 3]) %
mod;
;
;
;
cnt[i] += bt[ttt][mmm];
if (mb[mmm] != -1) {
hv[i] = t * K + mb[mmm];
}
}
}
}
void clear() { *this = Solution(); }
};
Solution sol;
int main() {
;
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int N = 30000;
const int M = 30000;
struct Input {
int mod;
int n, m;
int a[N];
int l[M], r[M];
bool read() {
if (!(cin >> n >> mod)) {
return 0;
}
for (int i = int(0); i < int(n); ++i) {
scanf("%d", &a[i]);
}
cin >> m;
for (int i = int(0); i < int(m); ++i) {
scanf("%d%d", &l[i], &r[i]);
--l[i];
}
return 1;
}
void init(const Input& input) { *this = input; }
};
struct Data : Input {
int ans[M];
void write() {
for (int i = int(0); i < int(m); ++i) {
cout << ans[i] << endl;
}
}
virtual void solve() {}
virtual void clear() { *this = Data(); }
};
struct Solution : Data {
static const int K = 11;
static const int D = N / K + 1;
int f[N + 10];
int p[N], rev[N];
int cnt[M];
int hv[M];
int msk[N + 1];
int mb[1 << K], bt[2][1 << K], v[2][1 << K][2];
void solve() {
f[0] = 1;
f[1] = 0;
for (int i = int(0); i < int(N + 8); ++i) {
f[i + 2] = (f[i] + f[i + 1]) % mod;
}
for (int i = int(0); i < int(n); ++i) {
p[i] = i;
}
sort(p, p + n, [&](int i, int j) { return a[i] < a[j]; });
for (int i = int(0); i < int(n); ++i) {
rev[p[i]] = i;
}
mb[0] = -1;
for (int i = int(0); i < int(K); ++i) {
for (int q = int(0); q < int(1 << i); ++q) {
mb[q | (1 << i)] = i;
}
}
memset(ans, 0, sizeof ans);
memset(cnt, 0, sizeof cnt);
memset(hv, -1, sizeof hv);
for (int t = int(0); t < int(D); ++t) {
if (t * K >= n) {
break;
}
msk[0] = 0;
for (int i = int(0); i < int(n); ++i) {
msk[i + 1] = msk[i];
if (rev[i] >= t * K && rev[i] < (t + 1) * K) {
msk[i + 1] |= 1 << (rev[i] - t * K);
}
}
memset(v, 0, sizeof v);
memset(bt, 0, sizeof bt);
for (int w = int(0); w < int(2); ++w) {
for (int i = int(0); i < int(min(K, n - t * K)); ++i) {
for (int q = int(0); q < int(1 << i); ++q) {
if (i ? (a[p[t * K + i]] == a[p[t * K + i - 1]]) : w) {
int q0 = i ? (q | (1 << (i - 1))) : q;
for (int z = int(0); z < int(2); ++z) {
v[w][q | (1 << i)][z] = v[w][q0][z];
}
bt[w][q | (1 << i)] = bt[w][q0];
} else {
for (int z = int(0); z < int(2); ++z) {
v[w][q | (1 << i)][z] =
(v[w][q][z] + f[bt[w][q] + z] * (a[p[t * K + i]] % mod)) %
mod;
}
bt[w][q | (1 << i)] = bt[w][q] + 1;
}
}
}
}
for (int i = int(0); i < int(m); ++i) {
int ttt = (hv[i] == -1) ? 0 : (a[p[hv[i]]] == a[p[t * K]]);
int mmm = msk[r[i]] & ~msk[l[i]];
for (int z = int(0); z < int(2); ++z) {
ans[i] = (ans[i] + v[ttt][mmm][z] * f[cnt[i] + 2 + z]) % mod;
}
cnt[i] += bt[ttt][mmm];
if (mb[mmm] != -1) {
hv[i] = t * K + mb[mmm];
}
}
}
}
void clear() { *this = Solution(); }
};
Solution sol;
int main() {
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct data {
int l, r, id, s;
int operator<(const data &b) const { return s != b.s ? s < b.s : r < b.r; }
} Q[30005];
int n, m, sign, P, i, L, R, S;
int have[30005 << 2], w[30005], b[30005], U[30005], pos[30005], num[30005],
ans[30005];
struct matrix {
int p[2][2];
inline matrix operator*(const matrix &b) const {
matrix c;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) {
c.p[i][j] = 0;
for (int k = 0; k < 2; k++) c.p[i][j] += p[i][k] * b.p[k][j];
c.p[i][j] %= P;
}
return c;
}
inline void operator+=(const matrix &b) {
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
if ((p[i][j] += b.p[i][j]) >= P) p[i][j] -= P;
}
} a[30005 << 2], Pow[30005];
void Insert(int x, int l, int r, int pos) {
if (l == r) {
a[x].p[0][0] = a[x].p[0][1] = a[x].p[1][0] = sign * w[l];
have[x] = sign;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
Insert(x << 1, l, mid, pos);
else
Insert(x << 1 | 1, mid + 1, r, pos);
have[x] = have[x << 1] + have[x << 1 | 1];
a[x] = a[x << 1];
a[x] += a[x << 1 | 1] * Pow[have[x << 1]];
}
int main() {
scanf("%d%d", &n, &P);
for (i = 1; i <= n; i++) scanf("%d", &U[i]), b[i] = U[i];
sort(U + 1, U + n + 1);
*U = unique(U + 1, U + n + 1) - (U + 1);
for (i = 1; i <= n; i++)
w[pos[i] = lower_bound(U + 1, U + *U + 1, b[i]) - U] = b[i] % P;
Pow[0].p[0][0] = Pow[0].p[1][1] = 1;
Pow[1].p[0][0] = Pow[1].p[0][1] = Pow[1].p[1][0] = 1;
for (i = 2; i <= n; i++) Pow[i] = Pow[i - 1] * Pow[1];
S = sqrt(n);
scanf("%d", &m);
for (i = 1; i <= m; i++)
scanf("%d%d", &Q[i].l, &Q[i].r), Q[i].id = i, Q[i].s = Q[i].l / S;
sort(Q + 1, Q + m + 1);
L = 1;
R = 0;
for (i = 1; i <= m; i++) {
sign = 1;
for (; R < Q[i].r;)
if ((++num[pos[++R]]) == 1) Insert(1, 1, n, pos[R]);
for (; L > Q[i].l;)
if ((++num[pos[--L]]) == 1) Insert(1, 1, n, pos[L]);
sign = 0;
for (; R > Q[i].r; R--)
if ((--num[pos[R]]) == 0) Insert(1, 1, n, pos[R]);
for (; L < Q[i].l; L++)
if ((--num[pos[L]]) == 0) Insert(1, 1, n, pos[L]);
ans[Q[i].id] = a[1].p[0][1];
}
for (i = 1; i <= m; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 30010, MaxT = 1 << 16, Block = 200;
int n, mod, q;
int a[MaxN], val[MaxN], vtot;
int inc(int x, int v) {
x += v;
return x >= mod ? x - mod : x;
}
struct query {
int l, r, id;
bool operator<(const query &a) const {
if (l / Block == a.l / Block) return r < a.r;
return l < a.l;
}
} Q[MaxN];
struct Matrix {
int c[2][2];
Matrix operator*=(const Matrix &a) {
int ret[2][2];
ret[0][0] = (c[0][0] * a.c[0][0] + c[0][1] * a.c[1][0]) % mod;
ret[0][1] = (c[0][0] * a.c[0][1] + c[0][1] * a.c[1][1]) % mod;
ret[1][0] = (c[1][0] * a.c[0][0] + c[1][1] * a.c[1][0]) % mod;
ret[1][1] = (c[1][0] * a.c[0][1] + c[1][1] * a.c[1][1]) % mod;
memcpy(c, ret, sizeof(ret));
return *this;
}
Matrix operator*(const Matrix &a) const {
Matrix ret;
ret.c[0][0] = (c[0][0] * a.c[0][0] + c[0][1] * a.c[1][0]) % mod;
ret.c[0][1] = (c[0][0] * a.c[0][1] + c[0][1] * a.c[1][1]) % mod;
ret.c[1][0] = (c[1][0] * a.c[0][0] + c[1][1] * a.c[1][0]) % mod;
ret.c[1][1] = (c[1][0] * a.c[0][1] + c[1][1] * a.c[1][1]) % mod;
return ret;
}
} I, F, pow_F[MaxN * 2], invF, *power;
struct Vector {
int c[2];
Vector() {}
Vector(int x, int y) { c[0] = x, c[1] = y; }
Vector operator*=(const Matrix &a) {
int ret[2];
ret[0] = (a.c[0][0] * c[0] + a.c[0][1] * c[1]) % mod;
ret[1] = (a.c[1][0] * c[0] + a.c[1][1] * c[1]) % mod;
memcpy(c, ret, sizeof(ret));
return *this;
}
Vector operator+(const Vector &a) const {
return Vector(inc(c[0], a.c[0]), inc(c[1], a.c[1]));
}
};
int ans[MaxN];
struct Tree_node {
int lazy;
Vector sum;
} T[MaxT];
void set_lazy(int now, int d) {
if (!d) return;
T[now].sum *= power[d];
T[now].lazy += d;
}
void push_down(int now) {
set_lazy(now << 1, T[now].lazy);
set_lazy(now << 1 | 1, T[now].lazy);
T[now].lazy = 0;
}
void update(int now) { T[now].sum = T[now << 1].sum + T[now << 1 | 1].sum; }
void modify_c(int l, int r, int x, int now, int d) {
if (l == r) {
T[now].sum.c[0] = power[T[now].lazy].c[0][0] * d % mod;
T[now].sum.c[1] = power[T[now].lazy].c[1][0] * d % mod;
return;
}
int mid = (l + r) >> 1;
push_down(now);
if (x <= mid)
modify_c(l, mid, x, now << 1, d);
else
modify_c(mid + 1, r, x, now << 1 | 1, d);
update(now);
}
void modify_mul(int l, int r, int x, int now, int d) {
if (r < x) return;
if (x <= l) return set_lazy(now, d);
int mid = (l + r) >> 1;
push_down(now);
modify_mul(l, mid, x, now << 1, d);
modify_mul(mid + 1, r, x, now << 1 | 1, d);
update(now);
}
void init() {
I.c[0][0] = I.c[1][1] = 1;
F.c[0][0] = F.c[0][1] = F.c[1][0] = 1;
invF.c[0][1] = invF.c[1][0] = 1;
invF.c[1][1] = mod - 1;
power = pow_F + MaxN;
power[0] = I;
for (int i = 1; i <= n; ++i) power[i] = power[i - 1] * F;
for (int i = 1; i <= n; ++i) power[-i] = power[-i + 1] * invF;
}
int cnt[MaxN];
bool inside[MaxN];
void do_reverse(int pos) {
int u = a[pos];
if (inside[pos]) {
if (--cnt[u] == 0) {
modify_c(1, vtot, u, 1, 0);
modify_mul(1, vtot, u + 1, 1, -1);
}
} else {
if (cnt[u]++ == 0) {
modify_c(1, vtot, u, 1, val[u] % mod);
modify_mul(1, vtot, u + 1, 1, 1);
}
}
inside[pos] ^= 1;
}
void move(int &last, int to) {
while (last < to) do_reverse(++last);
while (last > to) do_reverse(last--);
}
int main() {
scanf("%d%d", &n, &mod);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
val[i] = a[i];
}
sort(val + 1, val + n + 1);
vtot = unique(val + 1, val + n + 1) - val - 1;
for (int i = 1; i <= n; ++i)
a[i] = lower_bound(val + 1, val + vtot + 1, a[i]) - val;
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
scanf("%d%d", &Q[i].l, &Q[i].r);
Q[i].id = i;
}
sort(Q + 1, Q + q + 1);
init();
int l = 0, r = 0;
for (int i = 1; i <= q; ++i) {
move(l, Q[i].l - 1);
move(r, Q[i].r);
ans[Q[i].id] = T[1].sum.c[0];
}
for (int i = 1; i <= q; ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 3e4 + 50;
int n, mod, q, a[maxn], fib[maxn << 1], pos[maxn];
int d, un[maxn], ranks[maxn];
int cnt[maxn];
int L = 1, R = 0, ans[maxn];
struct node {
int l, r, id;
} Q[maxn];
bool cmp(node a, node b) {
if (pos[a.l] == pos[b.l]) return a.r < b.r;
return a.l < b.l;
}
int lazy[maxn << 2], fx_1[maxn << 2], fx[maxn << 2];
void shift(int sign, int p) {
int a = (fx_1[sign] * fib[d + p] + fx[sign] * fib[d + p + 1]) % mod;
int b = (fx_1[sign] * fib[d + p - 1] + fx[sign] * fib[d + p]) % mod;
fx_1[sign] = b, fx[sign] = a;
}
void pushup(int sign) {
fx_1[sign] = (fx_1[sign << 1] + fx_1[sign << 1 | 1]) % mod;
fx[sign] = (fx[sign << 1] + fx[sign << 1 | 1]) % mod;
}
void pushdown(int sign) {
if (lazy[sign]) {
lazy[sign << 1] += lazy[sign];
lazy[sign << 1 | 1] += lazy[sign];
shift(sign << 1, lazy[sign]);
shift(sign << 1 | 1, lazy[sign]);
lazy[sign] = 0;
}
}
void right(int sign, int l, int r, int x) {
if (l == r) {
fx_1[sign] = un[l] % mod * fib[d + lazy[sign]] % mod;
fx[sign] = un[l] % mod * fib[d + lazy[sign] + 1] % mod;
return;
}
pushdown(sign);
int mid = (l + r) >> 1;
if (x <= mid) {
right(sign << 1, l, mid, x);
lazy[sign << 1 | 1]++;
shift(sign << 1 | 1, 1);
} else {
right(sign << 1 | 1, mid + 1, r, x);
}
pushup(sign);
}
void left(int sign, int l, int r, int x) {
if (l == r) {
fx_1[sign] = fx[sign] = 0;
return;
}
pushdown(sign);
int mid = (l + r) >> 1;
if (x <= mid) {
left(sign << 1, l, mid, x);
lazy[sign << 1 | 1]--;
shift(sign << 1 | 1, -1);
} else {
left(sign << 1 | 1, mid + 1, r, x);
}
pushup(sign);
}
void add(int x) {
if (++cnt[ranks[x]] == 1) right(1, 1, d, ranks[x]);
}
void del(int x) {
if (--cnt[ranks[x]] == 0) left(1, 1, d, ranks[x]);
}
void init_fib() {
fib[d] = 0, fib[d + 1] = 1;
for (int i = d + 2; i <= (d << 1); i++)
fib[i] = (fib[i - 1] + fib[i - 2]) % mod;
for (int i = d - 1; i >= 0; i--)
fib[i] = (fib[i + 2] - fib[i + 1] + mod) % mod;
}
int main() {
scanf("%d %d", &n, &mod);
int sz = sqrt(n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
un[i] = a[i];
pos[i] = i / sz;
}
sort(un + 1, un + 1 + n);
d = unique(un + 1, un + 1 + n) - (un + 1);
for (int i = 1; i <= n; i++)
ranks[i] = lower_bound(un + 1, un + 1 + d, a[i]) - un;
init_fib();
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d %d", &Q[i].l, &Q[i].r);
Q[i].id = i;
}
sort(Q + 1, Q + 1 + q, cmp);
for (int i = 1; i <= q; i++) {
while (Q[i].l < L) add(--L);
while (Q[i].l > L) del(L++);
while (Q[i].r > R) add(++R);
while (Q[i].r < R) del(R--);
ans[Q[i].id] = fx[1];
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 30005;
int Q, B, bel[N];
struct query {
int l, r, id;
bool operator<(const query &R) const {
if (bel[l] != bel[R.l]) return bel[l] < bel[R.l];
return r < R.r;
if (bel[l] & 1)
return r < R.r;
else
return R.r < r;
}
} q[N];
int n, m, a[N], d[N], D;
int cnt[N], res[N];
int fib[N][2];
struct stree {
int a0, a1;
int s;
} t[N << 1];
inline int id(int l, int r) { return l + r | l != r; }
void pushup(int p, int l, int mid, int r) {
int L = id(l, mid), R = id(mid + 1, r);
t[p].s = t[L].s + t[R].s;
t[p].a0 = (t[L].a0 + fib[t[L].s][0] * t[R].a0 + fib[t[L].s][1] * t[R].a1) % Q;
t[p].a1 =
(t[L].a1 + fib[t[L].s + 1][0] * t[R].a0 + fib[t[L].s + 1][1] * t[R].a1) %
Q;
}
void modify(int l, int r, int x, int w) {
int p = id(l, r);
if (l == r) {
t[p].s = w;
t[p].a0 = t[p].a1 = w * d[x] % Q;
return;
}
int mid = l + r >> 1;
if (x <= mid)
modify(l, mid, x, w);
else
modify(mid + 1, r, x, w);
pushup(p, l, mid, r);
}
void add(int i) {
int x = a[i];
if (++cnt[x] == 1) {
modify(0, D, x, 1);
}
}
void del(int i) {
int x = a[i];
if (--cnt[x] == 0) {
modify(0, D, x, 0);
}
}
int main() {
scanf("%d%d", &n, &Q);
B = sqrt(n);
fib[0][0] = 1, fib[1][1] = 1;
for (int i = 2; i <= n; ++i) {
fib[i][0] = (fib[i - 2][0] + fib[i - 1][0]) % Q;
fib[i][1] = (fib[i - 2][1] + fib[i - 1][1]) % Q;
}
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
d[D++] = a[i];
bel[i] = i / B;
}
sort(d, d + D);
D = unique(d, d + D) - d;
for (int i = 0; i < n; ++i) {
a[i] = lower_bound(d, d + D, a[i]) - d;
}
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
q[i] = (query){--x, --y, i};
}
sort(q, q + m);
int l = 0, r = -1;
for (int i = 0; i < m; ++i) {
while (r < q[i].r) {
add(++r);
}
while (l > q[i].l) {
add(--l);
}
while (r > q[i].r) {
del(r--);
}
while (l < q[i].l) {
del(l++);
}
res[q[i].id] = t[id(0, D)].a0 % Q;
}
for (int i = 0; i < m; ++i) printf("%d\n", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e4 + 5;
int mod, n, m, a[maxn], b[maxn], c[maxn], used[maxn], block, ans[maxn];
bool vis[maxn];
struct query {
int l, r, id;
bool operator<(const query &a) const {
return l / block != a.l / block ? l / block < a.l / block : r < a.r;
}
} Q[maxn];
struct segtree {
int node[maxn << 2][2][3];
void build(int rt, int l, int r) {
memset(node[rt], 0, sizeof(node[rt]));
node[rt][0][0] = node[rt][1][1] = 1;
if (l == r) return;
int mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
}
void update(int rt, int l, int r, int x, int k) {
if (l == r) {
if (k) {
node[rt][0][0] = node[rt][0][1] = node[rt][1][0] = 1;
node[rt][1][1] = 0;
node[rt][0][2] = node[rt][1][2] = c[x];
} else {
memset(node[rt], 0, sizeof(node[rt]));
node[rt][0][0] = node[rt][1][1] = 1;
}
return;
}
int mid = (l + r) >> 1;
x <= mid ? update(rt << 1, l, mid, x, k)
: update(rt << 1 | 1, mid + 1, r, x, k);
node[rt][0][0] = (node[rt << 1][0][0] * node[rt << 1 | 1][0][0] +
node[rt << 1][0][1] * node[rt << 1 | 1][1][0]) %
mod;
node[rt][0][1] = (node[rt << 1][0][0] * node[rt << 1 | 1][0][1] +
node[rt << 1][0][1] * node[rt << 1 | 1][1][1]) %
mod;
node[rt][0][2] =
(node[rt << 1][0][0] * node[rt << 1 | 1][0][2] +
node[rt << 1][0][1] * node[rt << 1 | 1][1][2] + node[rt << 1][0][2]) %
mod;
node[rt][1][0] = (node[rt << 1][1][0] * node[rt << 1 | 1][0][0] +
node[rt << 1][1][1] * node[rt << 1 | 1][1][0]) %
mod;
node[rt][1][1] = (node[rt << 1][1][0] * node[rt << 1 | 1][0][1] +
node[rt << 1][1][1] * node[rt << 1 | 1][1][1]) %
mod;
node[rt][1][2] =
(node[rt << 1][1][0] * node[rt << 1 | 1][0][2] +
node[rt << 1][1][1] * node[rt << 1 | 1][1][2] + node[rt << 1][1][2]) %
mod;
}
} tree;
void add(int x) {
if (++used[x] == 1) tree.update(1, 1, m, x, 1);
}
void del(int x) {
if (--used[x] == 0) tree.update(1, 1, m, x, 0);
}
void work(int x) {
if (vis[x]) {
vis[x] = false;
del(a[x]);
} else {
vis[x] = true;
add(a[x]);
}
}
int main() {
while (~scanf("%d%d", &n, &mod)) {
block = sqrt(n + 0.5);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
b[i] = a[i];
}
sort(b + 1, b + n + 1);
m = unique(b + 1, b + n + 1) - b - 1;
for (int i = 1; i <= m; ++i) c[i] = b[i] % mod;
for (int i = 1; i <= n; ++i) a[i] = lower_bound(b + 1, b + m + 1, a[i]) - b;
tree.build(1, 1, m);
int q;
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
scanf("%d%d", &Q[i].l, &Q[i].r);
Q[i].id = i;
}
sort(Q, Q + q);
memset(vis, 0, sizeof(vis));
memset(used, 0, sizeof(used));
int l = Q[0].l, r = Q[0].r;
for (int i = l; i <= r; ++i) work(i);
ans[Q[0].id] = tree.node[1][1][2];
for (int i = 1; i < q; ++i) {
while (l < Q[i].l) work(l++);
while (l > Q[i].l) work(--l);
while (r < Q[i].r) work(++r);
while (r > Q[i].r) work(r--);
ans[Q[i].id] = tree.node[1][1][2];
}
for (int i = 0; i < q; ++i) printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 30005;
int n, m, a[N], b[N], c[N], f[N], q, tot, l, r;
int ef(int x) {
int l = 1, r = tot;
while (l < r) {
int mid = (l + r) / 2;
if (b[mid] < x)
l = mid + 1;
else
r = mid;
}
return l;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), b[i] = a[i];
sort(b + 1, b + n + 1);
tot = 1;
for (int i = 2; i <= n; i++)
if (b[i] != b[tot]) b[++tot] = b[i];
for (int i = 1; i <= n; i++) a[i] = ef(a[i]);
for (int i = 1; i <= tot; i++) b[i] %= m;
f[1] = f[2] = 1;
for (int i = 3; i <= n; i++) f[i] = (f[i - 1] + f[i - 2]) % m;
scanf("%d", &q);
while (q--) {
scanf("%d%d", &l, &r);
long long ans = 0;
int cnt = 0;
memset(c, 0, sizeof c);
for (int i = l; i <= r; i++) c[a[i]] = 1;
for (int i = 1; i <= tot; i++)
if (c[i]) cnt++, ans += f[cnt] * b[i];
printf("%lld\n", ans % m);
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
using namespace std;
bool Finish_read;
template <class T>
inline void read(T &x) {
Finish_read = 0;
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
if (ch == EOF) return;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x *= f;
Finish_read = 1;
}
template <class T>
inline void print(T x) {
if (x / 10 != 0) print(x / 10);
putchar(x % 10 + '0');
}
template <class T>
inline void writeln(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
putchar('\n');
}
template <class T>
inline void write(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
}
const int maxn = 30005;
struct node {
int x, id;
inline bool operator<(const node &rhs) const {
return x == rhs.x ? id < rhs.id : x < rhs.x;
}
} a[maxn];
int n, mod, f[maxn], lst[maxn], q, l[maxn], r[maxn], ans[maxn], cnt[maxn];
int main() {
memset(lst, -1, sizeof lst);
read(n), read(mod);
f[1] = f[2] = 1;
for (register int i = 3; i <= n; ++i) f[i] = (f[i - 1] + f[i - 2]) % mod;
for (register int i = 1; i <= n; ++i) read(a[i].x), a[i].id = i;
sort(a + 1, a + n + 1);
read(q);
for (register int i = 1; i <= q; ++i) read(l[i]), read(r[i]);
for (register int i = 1; i <= n; ++i) {
register int tmp = a[i].x % mod;
for (register int j = 1; j <= q; ++j)
if (l[j] <= a[i].id && a[i].id <= r[j] && a[i].x != lst[j]) {
lst[j] = a[i].x, ans[j] += f[++cnt[j]] * tmp % mod;
if (ans[j] >= mod) ans[j] -= mod;
}
}
for (register int i = 1; i <= q; ++i) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e4 + 1;
int n, m, q, f[N], a[N];
vector<int> vec;
bitset<N> bit;
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
vec.push_back(a[i]);
}
f[1] = f[2] = 1;
for (int i = 3; i <= n; i++) {
f[i] = (f[i - 1] + f[i - 2]) % m;
}
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
for (int i = 1; i <= n; i++) {
a[i] = lower_bound(vec.begin(), vec.end(), a[i]) - vec.begin();
}
scanf("%d", &q);
while (q--) {
int l, r, cn = 1;
long long ans = 0;
scanf("%d %d", &l, &r);
for (int i = l; i <= r; i++) {
bit[a[i]] = 1;
}
for (int i = 0; i < vec.size(); i++) {
if (bit[i]) {
ans = (ans + vec[i] * 1ll * f[cn++]) % m;
}
}
for (int i = l; i <= r; i++) {
bit[a[i]] = 0;
}
printf("%I64d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int first[33333];
pair<int, int> a[33333];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].first);
a[i].second = i;
}
sort(a, a + n);
first[0] = first[1] = 1 % m;
for (int i = 2; i <= n; i++) {
first[i] = first[i - 1] + first[i - 2];
if (first[i] >= m) {
first[i] -= m;
}
}
int l, r, q;
scanf("%d", &q);
while (q--) {
scanf("%d%d", &l, &r);
--l, --r;
long long sum = 0, color = -1, i = 0;
for (int j = 0; j < n; j++) {
if (color == a[j].first) continue;
if (l <= a[j].second && a[j].second <= r) {
color = a[j].first;
sum += 1ll * first[i++] * a[j].first;
}
}
printf("%d\n", int(sum % m));
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int n, mod;
cin >> n >> mod;
vector<pair<int, int> > v(n);
vector<int> val(n);
vector<int> idx(n);
vector<int> F(n, 1);
for (int i = (2); i < int(n); ++i) F[i] = (F[i - 1] + F[i - 2]) % mod;
for (int i = (0); i < int(n); ++i) {
cin >> v[i].first;
v[i].second = i;
}
sort((v).begin(), (v).end());
long long prev = -1;
int k = -1;
for (auto &i : v) {
if (i.first != prev) val[++k] = (prev = i.first) % mod;
idx[i.second] = k;
}
vector<int> cs(n, -1);
vector<int> a(++k);
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
int x = k - 1, y = 0;
for (int i = (l - 1); i < int(r); ++i) {
int &p = idx[i];
cs[p] = q;
x -= (p < x) * (x - p);
y += (p > y) * (p - y);
}
int m = 0;
for (int i = (x); i < int(y + 1); ++i)
if (cs[i] == q) a[m++] = val[i];
long long sum = 0;
for (int i = (0); i < int(m); ++i) sum += a[i] * F[i];
cout << sum % mod << "\n";
}
exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXK = 3;
const int MAXN = 30005;
map<int, int> Mp;
int V[MAXN], Cnt, cnt[MAXN];
int N, M, A[MAXN], B[MAXN];
int Q, stq, L, R, Ans[MAXN];
struct Matr {
int a[MAXK][MAXK];
} I, It[MAXN];
Matr cheng(Matr A, Matr B) {
Matr rt;
memset(rt.a, 0, sizeof(rt.a));
for (int i = 1; i <= 2; i++)
for (int j = 1; j <= 2; j++)
for (int k = 1; k <= 2; k++)
rt.a[i][j] = (rt.a[i][j] + A.a[i][k] * B.a[k][j]) % M;
return rt;
}
struct que {
int l, r, id;
} q[MAXN];
struct Node {
int l, r, cnt, siz, sum0, sum1;
} s[MAXN * 8];
bool cmp(que A, que B) {
return A.l / stq == B.l / stq ? A.r < B.r : A.l < B.l;
}
void Prepare() {
I.a[1][1] = 0;
I.a[1][2] = 1;
I.a[2][1] = 1;
I.a[2][2] = 1;
It[0].a[1][1] = 1;
It[0].a[1][2] = 0;
It[0].a[2][1] = 0;
It[0].a[2][2] = 1;
for (int i = 1; i <= N + 1; i++) It[i] = cheng(It[i - 1], I);
}
void Push_Up(int rt) {
s[rt].cnt = s[rt * 2].cnt + s[rt * 2 + 1].cnt;
s[rt].siz = s[rt * 2].siz + s[rt * 2 + 1].siz;
int u = s[rt * 2].cnt;
s[rt].sum0 = (s[rt * 2].sum0 + s[rt * 2 + 1].sum0 * It[u].a[1][1] +
s[rt * 2 + 1].sum1 * It[u].a[1][2]) %
M;
s[rt].sum1 = (s[rt * 2].sum1 + s[rt * 2 + 1].sum0 * It[u + 1].a[1][1] +
s[rt * 2 + 1].sum1 * It[u + 1].a[1][2]) %
M;
}
void Build(int rt, int l, int r) {
s[rt].l = l;
s[rt].r = r;
s[rt].cnt = s[rt].siz = 0;
s[rt].sum0 = s[rt].sum1 = 0;
if (l == r) return;
int mid = (l + r) / 2;
Build(rt * 2, l, mid);
Build(rt * 2 + 1, mid + 1, r);
}
void Insert(int rt, int p, int val) {
if (s[rt].r < p || s[rt].l > p) return;
if (s[rt].l == s[rt].r) {
if (s[rt].siz == 0) {
s[rt].cnt++;
s[rt].sum0 = V[p] % M;
s[rt].sum1 = V[p] % M;
}
s[rt].siz += val;
if (s[rt].siz == 0) {
s[rt].cnt--;
s[rt].sum0 = 0;
s[rt].sum1 = 0;
}
return;
}
Insert(rt * 2, p, val);
Insert(rt * 2 + 1, p, val);
Push_Up(rt);
}
void Add(int x) { Insert(1, Mp[A[x]], 1); }
void Remove(int x) { Insert(1, Mp[A[x]], -1); }
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) scanf("%d", &A[i]), B[i] = A[i];
sort(B + 1, B + N + 1);
Prepare();
for (int i = 1; i <= N; i++) {
if (!Mp[B[i]]) {
Mp[B[i]] = ++Cnt;
V[Cnt] = B[i];
}
}
scanf("%d", &Q);
stq = sqrt(Q);
for (int i = 1; i <= Q; i++) scanf("%d%d", &q[i].l, &q[i].r), q[i].id = i;
Build(1, 1, Cnt);
sort(q + 1, q + Q + 1, cmp);
L = R = 1;
Add(1);
for (int i = 1; i <= Q; i++) {
while (L < q[i].l) Remove(L++);
while (L > q[i].l) Add(--L);
while (R < q[i].r) Add(++R);
while (R > q[i].r) Remove(R--);
Ans[q[i].id] = s[1].sum0;
}
for (int i = 1; i <= Q; i++) printf("%d\n", Ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int mod = (int)1e+9 + 7;
const double pi = acos(-1.);
const int maxn = 30100;
pair<long long, int> a[maxn];
long long fib[maxn];
int main() {
{
srand(time(0));
const string file = "";
if (!file.empty()) {
freopen((file + ".in").c_str(), "r", stdin);
freopen((file + ".out").c_str(), "w", stdout);
}
}
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%lld", &a[i].first);
a[i].second = i + 1;
}
sort(&a[0], &a[n]);
fib[0] = fib[1] = 1;
for (int i = 2; i < n; i++) {
fib[i] = fib[i - 1] + fib[i - 2];
fib[i] -= fib[i] >= m ? m : 0;
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
long long ans = 0;
int l, r, lst = -1;
scanf("%d%d", &l, &r);
for (int j = 0, k = 0; j < n; ++j) {
if (a[j].second >= l && a[j].second <= r && a[j].first != lst) {
lst = a[j].first;
ans += fib[k++] * a[j].first;
}
}
ans %= m;
printf("%lld\n", ans);
}
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const double EPS = (long double)1e-7;
long long int fibs[40000], arr[40000], cnt[40000];
struct node {
long long int sz;
long long int sm0, sm1;
node(long long int a = 0, long long int b = 0, long long int c = 0) {
sz = a, sm0 = b, sm1 = c;
}
};
long long int md, n;
long long int up(long long int x1, long long int x2, long long int k) {
return !k ? x1 : (x1 * fibs[k - 1] + x2 * fibs[k]) % md;
}
void upd(node& n, node l, node r) {
long long int sz = l.sz;
n.sm0 = (l.sm0 + up(r.sm0, r.sm1, sz)) % md;
n.sm1 = (l.sm1 + up(r.sm0, r.sm1, sz + 1)) % md;
n.sz = sz + r.sz;
}
node t[2 * 40000];
void modify(int p, node x) {
for (t[p += n] = x; p >>= 1;) upd(t[p], t[p << 1], t[p << 1 | 1]);
}
void add(int x) {
if (!cnt[x]++) modify(x, node(1, 0, arr[x]));
}
void rem(int x) {
if (!--cnt[x]) modify(x, node(0, 0, 0));
}
int main() {
int n, q;
scanf("%d%I64d", &n, &md);
::n = 1;
while (::n < n) ::n *= 2;
fibs[0] = 0, fibs[1] = 1;
for (int i = (2); i < (int)(35000); ++i)
fibs[i] = (fibs[i - 1] + fibs[i - 2]) % md;
vector<int> v(n);
for (int i = (0); i < (int)(n); ++i) scanf("%d", &v[i]);
unordered_map<int, int> mq;
vector<int> w = v;
sort((w).begin(), (w).end());
for (int i = (0); i < (int)(n); ++i) arr[i] = w[i], mq[w[i]] = i;
cin >> q;
vector<tuple<int, int, int> > que(q);
for (int i = (0); i < (int)(q); ++i) {
int l, r;
scanf("%d%d", &l, &r);
que[i] = tuple<int, int, int>(l - 1, r - 1, i);
}
long long int s = sqrt(n);
sort((que).begin(), (que).end(),
[s](tuple<int, int, int>& a, tuple<int, int, int>& b) -> bool {
int al, ar, bl, br;
tie(al, ar, ignore) = a;
tie(bl, br, ignore) = b;
if (al / s != bl / s) return al < bl;
return (ar < br) ^ ((al / s) & 1);
});
vector<int> ans(q);
int l = get<1>(que[0]) + 1, r = l - 1;
for (tuple<int, int, int> q : que) {
int ql, qr, qi;
tie(ql, qr, qi) = q;
while (r < qr) add(mq[v[++r]]);
while (l > ql) add(mq[v[--l]]);
while (r > qr) rem(mq[v[r--]]);
while (l < ql) rem(mq[v[l++]]);
ans[qi] = t[1].sm1;
}
for (int i = (0); i < (int)(q); ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18 + 5;
const int logN = 17;
const int inf = 1e9;
const int N = 3e4 + 50;
int sum1[N << 2], sum0[N << 2], L[N << 2];
int sq;
int l, r, F[N], s, ans[N], mod, cnt[N], n, m, x, y, z, a[N], wh[N], start[N],
finish[N], belong[N], S, t;
vector<pair<pair<int, int>, int> > all;
map<int, int> H, w;
bool cmp(pair<pair<int, int>, int> x, pair<pair<int, int>, int> y) {
if (x.first.first / sq == y.first.first / sq)
return x.first.second < y.first.second;
return x < y;
}
int get(int x) {
if (x >= 0) return F[x];
if ((-x) & 1) return F[-x];
return mod - F[-x];
}
void merge(int k) {
t = L[k];
l = (k + k), r = (k + k + 1);
sum1[k] = (get(t + 1) * sum1[l] + get(t) * sum0[l]) % mod;
sum1[k] = (sum1[k] + get(t + 1) * sum1[r] + get(t) * sum0[r]) % mod;
sum0[k] = (get(t) * sum1[l] + get(t - 1) * sum0[l]) % mod;
sum0[k] = (sum0[k] + get(t) * sum1[r] + get(t - 1) * sum0[r]) % mod;
}
void assign(int k, int bas, int son, int x, int op) {
if (bas == son) {
L[k] += op;
if (!cnt[bas]) {
sum0[k] = sum1[k] = 0;
return;
}
sum1[k] = wh[bas] * get(L[k]) % mod;
sum0[k] = wh[bas] * get(L[k] - 1) % mod;
return;
}
if (x <= (bas + son >> 1)) {
assign((k + k), bas, (bas + son >> 1), x, op);
L[(k + k + 1)] += op;
if ((bas + son >> 1) + 1 == son) {
if (cnt[son]) {
sum1[(k + k + 1)] = wh[son] * get(L[(k + k + 1)]) % mod;
sum0[(k + k + 1)] = wh[son] * get(L[(k + k + 1)] - 1) % mod;
}
} else
merge((k + k + 1));
} else
assign((k + k + 1), (bas + son >> 1) + 1, son, x, op);
merge(k);
}
int get() { return sum1[1]; }
void add(int x) {
if (!cnt[x]++) assign(1, 1, s, x, +1);
}
void del(int x) {
if (!--cnt[x]) assign(1, 1, s, x, -1);
}
int main() {
scanf("%d %d", &n, &mod);
sq = sqrt(n);
F[1] = 1;
for (int i = 2; i <= n; i++) F[i] = (F[i - 1] + F[i - 2]) % mod;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
H[a[i]] = 1;
}
for (__typeof(H.begin()) it = H.begin(); it != H.end(); it++) {
w[it->first] = ++s;
wh[s] = it->first;
}
for (int i = 1; i <= n; i++) a[i] = w[a[i]];
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
all.push_back(make_pair(make_pair(x, y), i));
}
sort(all.begin(), all.end(), cmp);
int l = 1, r = 0;
for (__typeof(all.begin()) it = all.begin(); it != all.end(); it++) {
int x = it->first.first;
int y = it->first.second;
while (r < y) add(a[++r]);
while (l < x) del(a[l++]);
while (r > y) del(a[r--]);
while (l > x) add(a[--l]);
ans[it->second] = get();
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct ai {
int a, num;
bool operator<(const ai &B) const { return a < B.a; }
} a[30001];
int n, m, q, top;
int num[30001], l[30001], r[30001], la[30001];
int fi[30001];
int ans[30001];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].a);
a[i].num = i;
}
sort(a + 1, a + 1 + n);
fi[1] = 1;
for (int i = 2; i <= n; i++) fi[i] = (fi[i - 1] + fi[i - 2]) % m;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d%d", &l[i], &r[i]);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < q; j++) {
if (a[i].num < l[j] || a[i].num > r[j] || a[i].a == la[j]) continue;
ans[j] = (ans[j] + ((la[j] = a[i].a) % m) * (fi[++num[j]])) % m;
}
}
for (int i = 0; i < q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "Yes" : "No");
exit(0);
}
void addmod(int &x, int y, int mod) {
x += y;
if (x >= mod) x -= mod;
}
int fib[30005], l[30005], r[30005], la[30005], cnt[30005], ans[30005];
pair<int, int> a[30005];
void fmain() {
scanf("%d%d", &n, &m);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
scanf("%d", &a[i].first);
a[i].second = i;
}
sort(a + 1, a + 1 + n);
fib[1] = 1;
for (int i = 2; i <= n; i++) fib[i] = (fib[i - 1] + fib[i - 2]) % m;
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", l + i, r + i);
}
for (int(i) = 1; (i) <= (int)(n); (i)++) {
for (int(j) = 1; (j) <= (int)(q); (j)++) {
if (a[i].second < l[j] || a[i].second > r[j] || a[i].first == la[j])
continue;
la[j] = a[i].first;
addmod(ans[j], la[j] % m * fib[++cnt[j]] % m, m);
}
}
for (int(j) = 1; (j) <= (int)(q); (j)++) printf("%d\n", ans[j]);
}
int main() {
fmain();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0, p = 1;
char ch = getchar();
while (!(('0' <= ch && ch <= '9') || ch == '-')) ch = getchar();
if (ch == '-') p = -1, ch = getchar();
while ('0' <= ch && ch <= '9') sum = sum * 10 + ch - 48, ch = getchar();
return sum * p;
}
const int maxn = 3e4 + 20;
const int M = 200;
int n, mod, a[maxn], l[maxn], r[maxn], pos[maxn], p[maxn], q, s[maxn], tot;
inline void init() {
n = read();
mod = read();
for (int i = (1), _end_ = (n); i <= _end_; i++) a[i] = read(), s[i] = a[i];
q = read();
for (int i = (1), _end_ = (q); i <= _end_; i++)
p[i] = i, l[i] = read(), r[i] = read(), pos[i] = l[i] / M + 1;
sort(p + 1, p + q + 1, [](int a, int b) {
return l[a] / M == l[b] / M ? pos[a] & 1 ? r[a] < r[b] : r[a] > r[b]
: l[a] < l[b];
});
sort(s + 1, s + n + 1);
tot = n;
tot = unique(s + 1, s + tot + 1) - (s + 1);
for (int i = (1), _end_ = (n); i <= _end_; i++)
a[i] = lower_bound(s + 1, s + tot + 1, a[i]) - s;
}
struct matrix {
int a[2][2];
inline int* operator[](int index) { return a[index]; }
matrix() { memset(a, 0, sizeof(a)); }
matrix(int x) {
if (x == 1) a[0][0] = a[1][1] = 1, a[0][1] = a[1][0] = 0;
if (x == 2) a[0][0] = 0, a[0][1] = a[1][0] = a[1][1] = 1;
}
};
inline matrix operator*(matrix a, matrix b) {
matrix c;
for (int i = (0), _end_ = (1); i <= _end_; i++)
for (int j = (0), _end_ = (1); j <= _end_; j++) {
long long res = 0;
for (int k = (0), _end_ = (1); k <= _end_; k++)
res += (long long)a[i][k] * b[k][j];
c[i][j] = res % mod;
}
return c;
}
inline pair<int, int> operator*(pair<int, int> a, matrix b) {
return make_pair(
((long long)a.first * b[0][0] + (long long)a.second * b[1][0]) % mod,
((long long)a.first * b[0][1] + (long long)a.second * b[1][1]) % mod);
}
inline pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
return make_pair((a.first + b.first) % mod, (a.second + b.second) % mod);
}
matrix p2[maxn];
struct node {
pair<int, int> s;
int cs;
inline void Merge(node lc, node rc) {
s = lc.s + rc.s * p2[lc.cs];
cs = lc.cs + rc.cs;
}
};
node c[maxn << 2];
int vis[maxn];
void update(int x, int d, int o, int l, int r) {
if (l == r) {
c[o].cs += d;
if (c[o].cs)
c[o].s = make_pair(s[x], s[x]);
else
c[o].s = make_pair(0, 0);
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
update(x, d, (o << 1), l, mid);
else
update(x, d, (o << 1 | 1), mid + 1, r);
c[o].Merge(c[(o << 1)], c[(o << 1 | 1)]);
}
inline void work(int x, int d) {
if (!vis[x]) update(x, 1, 1, 1, n);
vis[x] += d;
if (!vis[x]) update(x, -1, 1, 1, n);
}
int ans[maxn];
inline void doing() {
p2[0] = matrix(1);
for (int i = (1), _end_ = (n); i <= _end_; i++) p2[i] = p2[i - 1] * matrix(2);
int L = 1, R = 0;
for (int i = (1), _end_ = (q); i <= _end_; i++) {
int u = p[i];
int ql = l[u], qr = r[u];
while (L > ql) work(a[--L], 1);
while (R < qr) work(a[++R], 1);
while (L < ql) work(a[L++], -1);
while (R > qr) work(a[R--], -1);
ans[u] = c[1].s.first;
}
for (int i = (1), _end_ = (q); i <= _end_; i++) printf("%d\n", ans[i]);
}
int main() {
init();
doing();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int F[30030];
int n;
int mod;
int a[30030], id[30030];
int nxt[30030];
bool cmp(int i, int j) { return a[i] < a[j]; }
int m;
int calc(int l, int r) {
int s = 0, m = 0;
for (int j, i = 1; i <= n; i++) {
j = id[i];
if (j >= l && j <= r) {
s = (s + F[++m] * a[j]) % mod;
i = nxt[i];
}
}
return s;
}
int main() {
scanf("%d %d", &n, &mod);
F[1] = F[2] = 1 % mod;
for (int i = 3; i <= n; i++) {
F[i] = (F[i - 1] + F[i - 2]) % mod;
}
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
id[i] = i;
}
sort(id + 1, id + n + 1, cmp);
nxt[n] = n;
for (int j = n - 1; j >= 1; j--) {
if (a[id[j]] == a[id[j + 1]]) {
nxt[j] = nxt[j + 1];
} else {
nxt[j] = j;
}
}
for (int j = 1; j <= n; j++) {
a[j] %= mod;
}
scanf("%d", &m);
for (int l, r, i = 1; i <= m; i++) {
scanf("%d %d", &l, &r);
printf("%d\n", calc(l, r));
}
return 0;
}
|
#include <bits/stdc++.h>
const int mod = 1000000007;
const int inf = 1000000009;
const long long INF = 1000000000000000009;
const long long big = 1000000000000000;
const long double eps = 0.0000000001;
using namespace std;
int T[21][100005], C[100005];
long long int DP[(1 << 20)][21];
int main() {
ios::sync_with_stdio(false);
cin.tie();
cout.tie();
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 1; j <= m; j++) {
char c;
cin >> c;
T[i][j] = c - '0';
}
for (int i = 1; i <= m; i++) {
for (int j = 0; j < n; j++) {
if (T[j][i]) C[i] += (1 << j);
}
DP[C[i]][0]++;
}
int wynik = inf;
for (int j = 1; j <= n; j++) {
for (int i = 0; i < (1 << n); i++) {
if (j >= 2) DP[i][j] += (long long int)(j - 2 - n) * DP[i][j - 2];
for (int k = 0; k < n; k++) DP[i][j] += DP[i ^ (1 << k)][j - 1];
DP[i][j] /= j;
}
}
for (int i = 0; i < (1 << n); i++) {
int aktual = 0;
for (int j = 0; j <= n; j++) aktual += DP[i][j] * min(j, n - j);
wynik = min(wynik, aktual);
}
cout << wynik;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 998244353, mod = 998244353;
const int N = 1 << 20;
long long a[N], b[N];
long long inv2 = (M + 1) / 2;
int n, i, m, j, s;
char c[25][100005];
void fwt(long long *f, int rev) {
for (int i = 1; i < (1 << n); i <<= 1) {
for (int p = i << 1, j = 0; j < (1 << n); j += p) {
for (int k = 0; k < i; k++) {
long long x = f[j + k], y = f[i + j + k];
if (rev == 1) {
f[j + k] = (x + y) % mod;
f[i + j + k] = (x - y + mod) % mod;
} else {
f[j + k] = 1ll * inv2 * (x + y) % mod;
f[i + j + k] = 1ll * inv2 * (x - y + mod) % mod;
}
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (i = 1; i <= n; ++i) scanf("%s", c[i] + 1);
for (i = 1; i <= m; ++i) {
s = 0;
for (j = 1; j <= n; ++j) s |= ((int)(c[j][i] - '0') << j - 1);
++a[s];
}
for (i = 0; i < (1 << n); ++i) {
int s = __builtin_popcount(i);
b[i] = min(s, n - s);
}
fwt(a, 1);
fwt(b, 1);
for (i = 0; i < (1 << n); ++i) a[i] = a[i] * b[i] % M;
fwt(a, -1);
long long ans = 10101010101ll;
for (i = 0; i < (1 << n); ++i) ans = min(ans, a[i]);
cout << ans;
}
|
#include <bits/stdc++.h>
const int N = 2000005;
long long a[N], b[N], c[N];
char s[N];
int read() {
int x = 0, v = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; v = (ch == '-') ? (-1) : (v), ch = getchar())
;
for (; ch <= '9' && ch >= '0'; x = x * 10 + ch - '0', ch = getchar())
;
return x * v;
}
void FWT(long long *a, int n, int f) {
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j += (i << 1)) {
for (int k = 0; k < i; ++k) {
long long u = a[j + k], v = a[j + k + i];
a[j + k] = u + v, a[j + k + i] = u - v;
if (f == -1) a[j + k] /= 2, a[j + k + i] /= 2;
}
}
}
}
int main(void) {
int n = read(), m = read();
for (int i = 1; i <= n; ++i) {
scanf("%s", s + 1);
for (int j = 1; j <= m; ++j) {
a[j] |= ((s[j] - '0') << i - 1);
}
}
for (int i = 1; i <= m; ++i) b[a[i]]++;
for (int i = 0; i <= (1 << n) - 1; ++i) c[i] = c[i >> 1] + (i & 1);
for (int i = 0; i <= (1 << n) - 1; ++i) c[i] = std::min(c[i], n - c[i]);
FWT(b, (1 << n), 1);
FWT(c, (1 << n), 1);
for (int i = 0; i <= (1 << n) - 1; ++i) b[i] *= c[i];
FWT(b, (1 << n), -1);
long long ans = 8000000;
for (int i = 0; i <= (1 << n) - 1; ++i) ans = std::min(ans, b[i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
};
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - 48;
ch = getchar();
};
return x * f;
}
long long n, m, g[21][100201], cot[1400021], dp[1400022], zt[1400201];
inline void FWTxor(long long *a, int id, int lim) {
for (int len = 1; len < lim; len <<= 1) {
for (int i = 0; i < lim; i += len << 1) {
long long *a1 = a + i, *a2 = a1 + len;
for (int j = 0; j < len; j++) {
long long x = a1[j], y = a2[j];
a1[j] = (x + y) / (id == 1 ? 1 : 2);
a2[j] = (x - y) / (id == 1 ? 1 : 2);
}
}
}
}
inline int getch() {
char s = getchar();
while (!isdigit(s)) s = getchar();
return s - '0';
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
g[i][j] = getch();
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
zt[i] |= (1 << j - 1) * g[j][i];
}
}
for (int i = 0; i <= (1 << n); i++) {
cot[i] = cot[i >> 1] + (i & 1);
}
for (int i = 0; i <= (1 << n); i++) {
cot[i] = min(cot[i], n - cot[i]);
}
for (int i = 1; i <= m; i++) {
dp[zt[i]]++;
}
FWTxor(dp, 1, 1 << n);
FWTxor(cot, 1, 1 << n);
for (int i = 0; i < (1 << n); i++) dp[i] *= cot[i];
FWTxor(dp, -1, 1 << n);
long long x = 999999999;
for (int i = 0; i < (1 << n); i++) x = min(dp[i], x);
cout << x << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 21, MAX = 1 << MAXN;
int dp[MAX][MAXN];
int a[MAX];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m;
char a1;
cin >> n >> m;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
cin >> a1;
a[j] = (a[j] << 1) + a1 - '0';
}
for (int i = 0; i < m; ++i) ++dp[a[i]][0];
int t = 1 << n;
for (int d = 1; d <= n; ++d)
for (int mask = 0; mask < t; ++mask) {
for (int i = 0; i < n; ++i) dp[mask][d] += dp[mask ^ (1 << i)][d - 1];
if (d > 1) dp[mask][d] -= dp[mask][d - 2] * (n - d + 2);
dp[mask][d] /= d;
}
int ans = n * m;
for (int mask = 0; mask < t; ++mask) {
int res = 0;
for (int i = 0; i <= n; ++i) res += min(i, n - i) * dp[mask][i];
ans = min(ans, res);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const long long NLINF = 0xf7f7f7f7f7f7f7f7;
const int INF = 0x3f3f3f3f, NINF = 0xf7f7f7f7;
const int MOD1 = 1e9 + 7, MOD2 = 1e9 + 9;
const int N = 21, M = 1e5 + 10;
int n, m, ans = INF, col[M], dp[N][1 << 20];
char s[N][M];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf(" %s", s[i] + 1);
for (int j = 1; j <= m; j++)
for (int i = 1; i <= n; i++)
if (s[i][j] == '1') col[j] |= (1 << (i - 1));
for (int i = 1; i <= m; i++) dp[0][col[i]]++;
for (int p = 0; p < n; p++) {
for (int i = n; i; i--)
for (int msk = 0; msk < (1 << n); msk++)
dp[i][msk] += dp[i - 1][msk ^ (1 << p)];
}
for (int msk = 0; msk < (1 << n); msk++) {
int cur = 0;
for (int i = 0; i <= n; i++) cur += min(i, n - i) * dp[i][msk];
ans = min(ans, cur);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 20);
int N;
long long f[maxn + 11], cnt[maxn + 11], ans[maxn + 11];
int a[22][maxn + 11];
char ch[maxn + 11];
void fwt(long long *a, int opt) {
for (int mid = 1; mid < N; mid <<= 1)
for (int R = mid << 1, j = 0; j < N; j += R)
for (int k = 0; k < mid; k++) {
long long x = a[j + k], y = a[j + k + mid];
if (opt == 1)
a[j + k] = x + y, a[j + k + mid] = x - y;
else
a[j + k] = (x + y) / 2, a[j + k + mid] = (x - y) / 2;
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", ch + 1);
for (int j = 1; j <= m; j++) a[i][j] = ch[j] - '0';
}
for (int i = 1; i <= m; i++) {
int x = 0;
for (int j = 1; j <= n; j++)
if (a[j][i]) x += (1 << (j - 1));
cnt[x]++;
}
N = (1 << n);
for (int i = 0; i < N; i++)
f[i] = min(__builtin_popcount(i), n - __builtin_popcount(i));
fwt(cnt, 1);
fwt(f, 1);
for (int i = 0; i < N; i++) ans[i] = cnt[i] * f[i];
fwt(ans, -1);
long long mx = n * m;
for (int i = 0; i < N; i++) mx = min(mx, ans[i]);
printf("%lld\n", mx);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, nn, one[(1 << 20) + 10], a[(1 << 20) + 10], b[(1 << 20) + 10];
string s[(1 << 20) + 10];
void solveinit() {
for (long long i = 1; i < nn; i++) {
if (i % 2 == 0) one[i] = one[i >> 1];
if (i % 2 == 1) one[i] = one[i >> 1] + 1;
}
for (long long i = 0; i < nn; i++) {
b[i] = min(one[i], n - one[i]);
}
}
void FWT(long long now[(1 << 20) + 10], long long l, long long r) {
if (l == r) return;
FWT(now, l, ((l + r) >> 1) + 0);
FWT(now, ((l + r) >> 1) + 1, r);
long long lpo = l, rpo = ((l + r) >> 1) + 1;
while (lpo <= ((l + r) >> 1)) {
now[lpo] = now[lpo] + now[rpo];
now[rpo] = now[lpo] - now[rpo] - now[rpo];
lpo++, rpo++;
}
}
void IFWT(long long now[(1 << 20) + 10], long long l, long long r) {
if (l == r) return;
long long lpo = l, rpo = ((l + r) >> 1) + 1;
while (lpo <= ((l + r) >> 1)) {
now[lpo] = (now[lpo] + now[rpo]) / 2;
now[rpo] = now[lpo] - now[rpo];
lpo++, rpo++;
}
IFWT(now, l, ((l + r) >> 1) + 0);
IFWT(now, ((l + r) >> 1) + 1, r);
}
int32_t main() {
cin.tie(0), cout.sync_with_stdio(0);
cin >> n >> m;
for (long long i = 0; i < n; i++) cin >> s[i];
for (long long i = 0; i < m; i++) {
long long val = 0;
for (long long j = 0; j < n; j++) val = val * 2 + s[j][i] - '0';
a[val]++;
}
nn = (1 << n);
solveinit();
FWT(a, 0, nn - 1), FWT(b, 0, nn - 1);
for (long long i = 0; i < nn; i++) a[i] = a[i] * b[i];
IFWT(a, 0, nn - 1);
long long ans = n * m + 10;
for (long long i = 0; i < nn; i++) ans = min(ans, a[i]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 21;
const int MX = 1 << MAXN;
const int MAXM = 1e5 + 9;
int n, m, mask, status[MAXM];
char s[MAXM];
long long cnt[MX], g[MX];
inline int neg(int x) { return x ^ mask; }
void Xor(long long *a, bool opt) {
for (int mid = 1; mid < mask; mid <<= 1)
for (int i = 0; i < mask; i += mid << 1)
for (int j = 0; j < mid; ++j) {
long long x = a[j + i] + a[j + i + mid], y = a[j + i] - a[j + i + mid];
a[j + i] = opt ? x : x >> 1, a[j + i + mid] = opt ? y : y >> 1;
}
}
int main() {
scanf("%d%d", &n, &m);
mask = (1 << n) - 1;
for (int i = 1; i <= n; ++i) {
scanf("%s", s + 1);
for (int j = 1; j <= m; ++j)
if (s[j] == '1') status[j] |= 1 << i - 1;
}
for (int i = 1; i <= m; ++i) ++cnt[status[i]];
for (int i = 0; i <= mask; ++i)
g[i] = std::min(__builtin_popcount(i), __builtin_popcount(neg(i)));
Xor(cnt, true), Xor(g, true);
for (int i = 0; i <= mask; ++i) cnt[i] *= g[i];
Xor(cnt, false);
printf("%lld\n", *std::min_element(cnt + 1, cnt + mask + 1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
const int maxn = 100001;
int a[maxn];
int cnt[20][1 << 10];
int pc[1 << 21];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
for (int i = 1; i <= (int)(1 << 20); ++i) {
pc[i] = pc[i & (i - 1)] + 1;
}
int n, m;
cin >> n >> m;
for (int i = 0; i < (int)(n); ++i) {
string s;
cin >> s;
for (int j = 0; j < (int)(m); ++j) a[j] |= (s[j] - '0') << i;
}
int BUBEN = min(14, n);
uax(BUBEN, 0);
int res = 1e9;
for (int i = 0; i < (int)(1 << BUBEN); ++i) {
for (int j = 0; j < (int)(BUBEN + 1); ++j)
for (int k = 0; k < (int)(1 << (n - BUBEN)); ++k) cnt[j][k] = 0;
for (int j = 0; j < (int)(m); ++j) {
++cnt[pc[(a[j] ^ i) & ((1 << BUBEN) - 1)]][a[j] >> BUBEN];
}
for (int j = 0; j < (int)(1 << (n - BUBEN)); ++j) {
int ans = 0;
for (int k = 0; k < (int)(BUBEN + 1); ++k)
for (int l = 0; l < (int)(1 << (n - BUBEN)); ++l) {
int z = k + pc[j ^ l];
uin(z, n - z);
ans += cnt[k][l] * z;
}
uin(res, ans);
}
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
string sep;
for (const auto &x : v) os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
namespace walsh_hadamard {
bool is_power_of_two(int n) { return (n & (n - 1)) == 0; }
int round_up_power_two(int n) {
while (n & (n - 1)) n = (n | (n - 1)) + 1;
return max(n, 1);
}
template <typename T>
void fwht_xor(int n, vector<T> &values, bool inverse = false) {
assert(is_power_of_two(n));
assert((int)values.size() >= n);
for (int len = 1; len < n; len *= 2)
for (int start = 0; start < n; start += 2 * len)
for (int i = start; i < start + len; i++) {
T u = values[i];
const T &v = values[i + len];
values[i] = u + v;
values[i + len] = u - v;
}
if (inverse) {
for (int i = 0; i < n; i++) values[i] /= n;
}
}
template <typename T_out, typename T_in>
vector<T_out> xor_convolution(const vector<T_in> &_left,
const vector<T_in> &_right,
bool circular = false) {
if (_left.empty() || _right.empty()) return {};
vector<T_out> left(_left.begin(), _left.end());
vector<T_out> right(_right.begin(), _right.end());
int n = left.size();
int m = right.size();
int output_size = circular ? round_up_power_two(max(n, m)) : n + m - 1;
int N = round_up_power_two(output_size);
left.resize(N, 0);
right.resize(N, 0);
if (left == right) {
fwht_xor(N, left);
right = left;
} else {
fwht_xor(N, left);
fwht_xor(N, right);
}
for (int i = 0; i < N; i++) left[i] *= right[i];
fwht_xor(N, left, true);
left.resize(output_size);
return left;
}
} // namespace walsh_hadamard
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N, M;
cin >> N >> M;
vector<string> table(N);
for (string &row : table) cin >> row;
vector<int> cost(1 << N, 0);
for (int mask = 0; mask < 1 << N; mask++) {
int count = __builtin_popcount(mask);
cost[mask] = min(count, N - count);
}
vector<int> freq(1 << N, 0);
for (int col = 0; col < M; col++) {
int mask = 0;
for (int i = 0; i < N; i++) mask |= (table[i][col] - '0') << i;
freq[mask]++;
}
vector<int64_t> result =
walsh_hadamard::xor_convolution<int64_t>(freq, cost, true);
cout << *min_element(result.begin(), result.end()) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
inline int readChar();
template <class T = int>
inline T readInt();
template <class T>
inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char *s);
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) {
pos = 0, len = fread(buf, 1, buf_size, stdin);
}
if (pos == len) {
return -1;
}
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32) {
c = getChar();
}
return c;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-') s = -1, c = getChar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
template <class T>
inline void writeInt(T x, char end) {
if (x < 0) writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n) s[n++] = '0' + x % 10, x /= 10;
while (n--) writeChar(s[n]);
if (end) writeChar(end);
}
inline void writeWord(const char *s) {
while (*s) writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
using namespace std;
const int MAXN = 100011;
const int INF = 1000000001;
char s[20][MAXN];
int n, m;
int dp[21 * MAXN][21];
inline void add(int x) {
int now = 0;
int cnt = __builtin_popcount(x);
for (int i = 0; i < n; i++) {
dp[now][cnt]++;
if ((x >> i) & 1) {
now <<= 1;
now += 2;
} else {
now <<= 1;
now++;
}
}
dp[now][cnt]++;
}
void change(int now, int h, int dist) {
if (h != dist) {
change((now << 1) + 1, h + 1, dist);
change((now << 1) + 2, h + 1, dist);
for (int i = 0; i <= n; i++) {
dp[now][i] = dp[(now << 1) + 1][i] + dp[(now << 1) + 2][i];
}
} else {
dp[now][0] = dp[(now << 1) + 2][1];
dp[now][n] = dp[(now << 1) + 1][n - 1];
for (int i = 1; i < n; i++) {
dp[now][i] = dp[(now << 1) + 1][i - 1] + dp[(now << 1) + 2][i + 1];
}
}
}
int main() {
n = readInt(), m = readInt();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
s[i][j] = readChar();
}
}
for (int i = 0; i < m; i++) {
int x = 0;
for (int j = 0; j < n; j++) {
x <<= 1;
x += s[j][i] - '0';
}
add(x);
}
int ans = n * m;
for (int i = 0; i < (1 << n); i++) {
int sum = 0;
for (int j = 0; j <= n; j++) {
sum += dp[0][j] * min(j, n - j);
}
chkmin(ans, sum);
if (i + 1 != (1 << n)) {
for (int j = 0; j < n; j++) {
if (((i >> j) & 1) == 0) {
change(0, 0, j);
break;
}
}
}
}
writeInt(ans, '\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
void FWT(long long *a, int n) {
for (int d = 1; d < n; d <<= 1) {
for (int m = d << 1, i = 0; i < n; i += m) {
for (int j = 0; j < d; ++j) {
long long x = a[i + j], y = a[i + j + d];
a[i + j] = x + y;
a[i + j + d] = x - y;
}
}
}
}
void UFWT(long long *a, int n) {
for (int d = 1; d < n; d <<= 1) {
for (int m = d << 1, i = 0; i < n; i += m) {
for (int j = 0; j < d; ++j) {
long long x = a[i + j], y = a[i + j + d];
a[i + j] = (x + y) / 2;
a[i + j + d] = (x - y) / 2;
}
}
}
}
void Sovle(long long *a, long long *b, int n) {
FWT(a, n);
FWT(b, n);
for (int i = 0; i < n; ++i) a[i] = a[i] * b[i];
UFWT(a, n);
}
int a[20][100000];
long long A[1 << 20];
long long B[1 << 20];
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%1d", &a[i][j]);
}
}
memset(A, 0, sizeof(A));
memset(B, 0, sizeof(B));
for (int j = 0; j < m; j++) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum <<= 1;
sum |= a[i][j];
}
A[sum]++;
}
for (int i = 0; i < (1 << n); i++) {
int cnt = 0;
for (int j = 0; j < n; j++) {
if (i >> j & 1) cnt++;
}
B[i] = min(cnt, n - cnt);
}
Sovle(A, B, 1 << n);
long long ret = 20 * 100000;
for (int i = 0; i < (1 << n); i++) ret = min(ret, A[i]);
printf("%lld\n", ret);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chkmin(T& x, T y) {
return x > y ? x = y, true : false;
}
template <class T>
inline bool chkmax(T& x, T y) {
return x < y ? x = y, true : false;
}
inline long long read(void) {
long long x, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (x = 0; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
int n, m, S;
long long a[((1 << 20) + 1)], b[((1 << 20) + 1)], c[((1 << 20) + 1)];
void fwt(long long* a, int len) {
if (len == 1) return;
int s = len >> 1;
fwt(a, s);
fwt(a + s, s);
for (int i = (0); i <= (s - 1); ++i) {
long long x = a[i], y = a[i + s];
a[i] = x + y;
a[i + s] = x - y;
}
}
void ifwt(long long* a, int len) {
if (len == 1) return;
int s = len >> 1;
for (int i = (0); i <= (s - 1); ++i) {
long long x = a[i], y = a[i + s];
a[i] = x + y >> 1;
a[i + s] = x - y >> 1;
}
ifwt(a, s);
ifwt(a + s, s);
}
int main(void) {
n = read();
m = read();
S = 1 << n;
for (int i = (0); i <= (S - 1); ++i)
a[i] = min(__builtin_popcount(i), n - __builtin_popcount(i));
for (int i = (0); i <= (n - 1); ++i) {
static char s[100005];
scanf("%s", s);
for (int j = (0); j <= (m - 1); ++j)
if (s[j] != '0') c[j] |= 1 << i;
}
for (int i = (0); i <= (m - 1); ++i) b[c[i]]++;
fwt(a, S);
fwt(b, S);
for (int i = (0); i <= (S - 1); ++i) a[i] *= b[i];
ifwt(a, S);
printf("%lld\n", *min_element(a, a + S));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = (1 << 20) + 10;
const long long INF = 2e9;
const long long G = 3;
const double PI = acos(-1);
long long n, m, ans = INF;
long long a[MAXN], b[MAXN], popcount[MAXN];
char mp[21][(long long)1e5 + 10];
template <typename T>
inline void read(T &a) {
a = 0;
char c = getchar();
long long f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
a = a * 10 + (c ^ 48);
c = getchar();
}
a *= f;
}
void FWT(long long *s, long long opt) {
for (long long mid = 1; mid < (1 << n); mid <<= 1)
for (long long i = 0; i < (1 << n); i += (mid << 1))
for (long long j = 0; j < mid; ++j) {
long long x = s[i + j], y = s[i + j + mid];
s[i + j] = x + y;
s[i + j + mid] = x - y;
if (opt == -1) s[i + j] >>= 1, s[i + j + mid] >>= 1;
}
}
signed main() {
read(n);
read(m);
for (long long i = 1; i <= n; ++i) scanf("%s", mp[i] + 1);
for (long long i = 1; i <= m; ++i) {
long long state = 0;
for (long long j = 1; j <= n; ++j) {
state <<= 1;
state |= (bool)(mp[j][i] == '1');
}
a[state]++;
}
for (long long i = 0; i <= (1 << n); ++i)
popcount[i] = popcount[i >> 1] + (i & 1);
for (long long i = 0; i < (1 << n); ++i)
b[i] = min(popcount[i], n - popcount[i]);
FWT(a, 1);
FWT(b, 1);
for (long long i = 0; i < (1 << n); ++i) a[i] *= b[i];
FWT(a, -1);
for (long long i = 0; i < (1 << n); ++i) ans = min(ans, a[i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int n, m, l, g[21][N];
long long A[1 << 21], B[1 << 21];
char s[N];
void FWT_xor(long long *P, int op) {
for (int i = 1; i < l; i <<= 1)
for (int j = 0, p = i << 1; j < l; j += p)
for (int k = 0; k < i; k++) {
long long X = P[j + k], Y = P[j + k + i];
P[j + k] = (X + Y) / op;
P[j + k + i] = (X - Y) / op;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (int j = 1; j <= m; j++) g[i][j] = s[j] - '0';
}
for (int h = 0, j = 1; j <= m; j++) {
for (int i = 1; i <= n; i++)
if (g[i][j]) h += (1 << (i - 1));
A[h]++;
h = 0;
}
l = 1 << n;
for (int i = 0, s = 0; i < l; i++) {
for (int j = 1; j <= n; j++)
if (i & (1 << (j - 1))) s++;
B[i] = min(s, n - s);
s = 0;
}
FWT_xor(A, 1);
FWT_xor(B, 1);
for (int i = 0; i < l; i++) A[i] *= B[i];
FWT_xor(A, 2);
long long ans = 1e13;
for (int i = 0; i < l; i++) ans = min(ans, A[i]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[22][1111111], a[2222222], n, m, ans;
char c;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
cin >> c, a[j] += (1 << i) * (c - '0'), ans += (c - '0');
for (int i = 0; i < m; i++) dp[0][a[i]]++;
for (int i = 0; i < n; i++)
for (int j = n; j; j--)
for (int mask = 0; mask < (1 << n); mask++)
dp[j][mask] += dp[j - 1][mask ^ (1 << i)];
for (int mask = (1 << n) - 1; mask >= 0; mask--) {
int cur = 0;
for (int i = 0; i <= n; i++) cur += min(i, n - i) * dp[i][mask];
ans = min(ans, cur);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[25][200001];
int n, m;
long long f[2000001], g[2000001];
void FWT(long long* f) {
for (int i = 0; i < (1 << n); i++) {
int cnt = 0;
for (int j = 0; j < n; j++)
if (i & (1 << j)) cnt++;
if (cnt & 1) f[i] = -f[i];
}
for (int i = 2; i <= (1 << n); i <<= 1)
for (int j = 0; j < (1 << n); j += i)
for (int k = j; k < j + i / 2; k++) {
long long fk = f[k];
f[k] = f[k] - f[k + i / 2];
f[k + i / 2] = fk + f[k + i / 2];
}
}
void IFWT(long long* f) {
FWT(f);
for (int i = 0; i < (1 << n); i++) f[i] >>= n;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s[i]);
for (int i = 0; i < m; i++) {
int x = 0;
for (int j = 1; j <= n; j++)
if (s[j][i] == '1')
x = (x << 1) + 1;
else
x <<= 1;
f[x]++;
}
for (int i = 0; i < (1 << n); i++) {
int cnt = 0;
for (int j = 0; j < n; j++)
if (i & (1 << j)) cnt++;
g[i] = min(cnt, n - cnt);
}
FWT(f);
FWT(g);
for (int i = 0; i < (1 << n); i++) f[i] *= g[i];
IFWT(f);
int ans = 1e9;
for (int i = 0; i < (1 << n); i++) ans = min(ans, (int)f[i]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[20][100005];
long long dp[1 << 20];
int tmp[1 << 20];
int main() {
int n, m;
{
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf(" %s", str[i]);
for (int j = 0; j < m; j++) {
int val = 0;
for (int i = 0; i < n; i++) {
if (str[i][j] == '1') {
val |= 1 << i;
}
}
dp[val]++;
}
}
for (int i = 0; i < (1 << n); i++) {
tmp[i] = __builtin_popcount(i);
tmp[i] = min(tmp[i], n - tmp[i]);
}
for (int b = 1; b < (1 << n); b *= 2) {
for (int st = 0; st < (1 << n); st += 2 * b) {
for (int i = 0; i < b; i++) {
{
auto a0 = dp[st + i];
auto a1 = dp[st + i + b];
dp[st + i] = a0 + a1;
dp[st + i + b] = a0 - a1;
}
{
auto a0 = tmp[st + i];
auto a1 = tmp[st + i + b];
tmp[st + i] = a0 + a1;
tmp[st + i + b] = a0 - a1;
}
}
}
}
for (int i = 0; i < (1 << n); i++) {
dp[i] *= tmp[i];
}
for (int b = 1; b < (1 << n); b *= 2) {
for (int st = 0; st < (1 << n); st += 2 * b) {
for (int i = 0; i < b; i++) {
auto a0 = dp[st + i];
auto a1 = dp[st + i + b];
dp[st + i] = (a0 + a1) / 2;
dp[st + i + b] = (a0 - a1) / 2;
}
}
}
int ans = int(1e9);
for (int i = 0; i < (1 << n); i++) {
ans = min(ans, (int)dp[i]);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
void fwht(int *p, int n) {
for (int len = 1; 2 * len <= n; len <<= 1) {
for (int i = 0; i < n; i += 2 * len) {
for (int j = 0; j < len; j++) {
int a = p[i + j];
int b = p[i + j + len];
p[i + j] = a + b >= mod ? a + b - mod : a + b;
p[i + j + len] = a - b < 0 ? a - b + mod : a - b;
}
}
}
}
int p[1 << 20];
int a[20][100000], n, m;
int A[1 << 20], B[1 << 20];
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c;
scanf(" %c", &c);
a[i][j] = c - '0';
}
}
B[1] = 1;
for (int i = 2; i < (1 << n); i++) B[i] = B[i >> 1] + (i & 1);
for (int i = 0; i < (1 << n); i++) B[i] = min(B[i], n - B[i]);
for (int j = 0; j < m; j++) {
int x = 0;
for (int i = 0; i < n; i++)
if (a[i][j]) x |= 1 << i;
++A[x];
}
fwht(A, 1 << n);
fwht(B, 1 << n);
for (int i = 0; i < (1 << n); i++) A[i] = (long long)A[i] * B[i] % mod;
fwht(A, 1 << n);
int inv = 500000004, pow2 = 1;
for (int i = 0; i < n; i++) pow2 = (long long)pow2 * inv % mod;
int ans = 1e9;
for (int i = 0; i < (1 << n); i++) {
A[i] = (long long)A[i] * pow2 % mod;
ans = min(ans, A[i]);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
char s[2000005];
long long n, m, lim, ans = 2e15;
long long cnt[2000005], g[2000005];
long long a[2000005], b[2000005];
void FWT(long long *f) {
for (long long d = 1; d < lim; d <<= 1)
for (long long i = 0; i < lim; i += (d << 1))
for (long long j = 0; j < d; j++) {
long long x = f[i + j], y = f[i + j + d];
f[i + j] = x + y;
f[i + j + d] = x - y;
}
}
void IFWT(long long *f) {
for (long long d = 1; d < lim; d <<= 1)
for (long long i = 0; i < lim; i += (d << 1))
for (long long j = 0; j < d; j++) {
long long x = f[i + j], y = f[i + j + d];
f[i + j] = x + y >> 1;
f[i + j + d] = x - y >> 1;
}
}
signed main() {
scanf("%lld%lld", &n, &m);
lim = 1 << n;
for (long long i = 0; i < n; i++) {
scanf("%s", s);
for (long long j = 0; j < m; j++)
if (s[j] == '1') g[j] |= (1 << i);
}
for (long long i = 0; i < m; i++) a[g[i]]++;
for (long long i = 1; i < lim; i++) cnt[i] = cnt[i >> 1] + (i & 1);
for (long long i = 0; i < lim; i++) b[i] = min(cnt[i], n - cnt[i]);
FWT(a);
FWT(b);
for (long long i = 0; i < lim; i++) a[i] *= b[i];
IFWT(a);
for (long long i = 0; i < lim; i++) ans = min(ans, a[i]);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 20;
int const M = 101000;
int f[N + 1][1 << N], s[2][N + 1][1 << N];
char a[N][M];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < (n); ++i) scanf(" %s", a[i]);
for (int j = 0; j < (m); ++j) {
int t = 0;
for (int i = 0; i < (n); ++i) t = t << 1 | (a[i][j] == '1');
f[0][t]++;
}
for (int i = 0; i < (1 << n); ++i) s[0][0][i] = f[0][i];
for (int k = 1; k <= (n); ++k)
for (int i = 0; i < (1 << n); ++i) {
int t = 0;
int sg = (k - 1) & 1;
for (int j = 0; j < (n); ++j) {
t += s[sg][k - 1][i ^ (1 << j)];
if (k > 1) t -= s[sg ^ 1][k - 2][i];
}
t /= k;
f[k][i] = t;
for (int j = 0; j < (2); ++j) s[j][k][i] = s[j][k - 1][i];
if (k & 1)
s[1][k][i] += t;
else
s[0][k][i] += t;
}
int ans = 0x3f3f3f3f;
for (int i = 0; i < (1 << n); ++i) {
int t = 0;
for (int j = 0; j < (n + 1); ++j) t += f[j][i] * min(j, n - j);
ans = min(ans, t);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
char str[1048576];
long long ar[1048576], counter[1048576], dp[1048576];
void walsh_transform(long long* ar, int n) {
if (n == 0) return;
int i, m = n / 2;
walsh_transform(ar, m);
walsh_transform(ar + m, m);
for (i = 0; i < m; i++) {
long long x = ar[i], y = ar[i + m];
ar[i] = x + y, ar[i + m] = x - y;
}
}
void inverse_walsh_transform(long long* ar, int n) {
if (n == 0) return;
int i, m = n / 2;
inverse_walsh_transform(ar, m);
inverse_walsh_transform(ar + m, m);
for (i = 0; i < m; i++) {
long long x = ar[i], y = ar[i + m];
ar[i] = (x + y) / 2, ar[i + m] = (x - y) / 2;
}
}
int main() {
int n, m, i, j, k, x, y, mask;
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%s", str);
for (j = 0; j < m; j++) {
if (str[j] == 49) ar[j] |= (1 << i);
}
}
for (i = 0; i < m; i++) counter[ar[i]]++;
for (i = 0; i < (1 << n); i++) {
k = __builtin_popcount(i);
dp[i] = (k < (n - k) ? k : n - k);
}
walsh_transform(dp, 1 << n);
walsh_transform(counter, 1 << n);
for (i = 0; i < (1 << n); i++) ar[i] = counter[i] * dp[i];
inverse_walsh_transform(ar, 1 << n);
long long res = 1LL << 50;
for (i = 0; i < (1 << n); i++) {
if (ar[i] < res) res = ar[i];
}
printf("%lld\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 100005;
const int LG = (int)log2(MX) + 1;
const int BLOCK = 205;
const int inf = 1000000069;
const long long inf_ll = 8000000000000000069ll;
const long double inf_ld = (long double)inf_ll;
const long double eps = 1e-9;
const long long mod = 1000000007;
const int alpha = 30;
const int dxh[] = {1, 1, -1, -1, 2, 2, -2, -2};
const int dyh[] = {2, -2, 2, -2, 1, -1, 1, -1};
const int dx[] = {1, -1, 0, 0, 0, 0};
const int dy[] = {0, 0, 1, -1, 0, 0};
const int dz[] = {0, 0, 0, 0, 1, -1};
const int dxd[] = {1, 1, 1, 0, -1, -1, -1, 0};
const int dyd[] = {1, 0, -1, -1, -1, 0, 1, 1};
mt19937 rng(time(NULL));
bool untied = 0;
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
void unsyncIO() { cin.tie(0)->sync_with_stdio(0); }
void setIO(string s = "") {
if (!untied) unsyncIO(), untied = 1;
if (s.size()) {
setIn(s + ".in");
setOut(s + ".out");
}
}
void fwt(vector<long long> &a, int n) {
for (int len = 2; len <= n; len <<= 1) {
for (int i = 0; i < n; i += len) {
for (int j = 0; j < len / 2; j++) {
long long x = a[i + j], y = a[i + j + len / 2];
a[i + j] = x + y;
a[i + j + len / 2] = x - y;
}
}
}
}
void ifwt(vector<long long> &a, int n) {
for (int len = 2; len <= n; len <<= 1) {
for (int i = 0; i < n; i += len) {
for (int j = 0; j < len / 2; j++) {
long long x = a[i + j], y = a[i + j + len / 2];
a[i + j] = (x + y) / 2;
a[i + j + len / 2] = (x - y) / 2;
}
}
}
}
int n, m, mp[25][MX];
string s[25];
int main() {
setIO();
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < m; j++) mp[i][j] = (int)(s[i][j] - '0');
}
vector<long long> A(1 << n, 0), B(1 << n, 0);
for (int j = 0; j < m; j++) {
int msk = 0;
for (int i = 0; i < n; i++) msk = 2 * msk + mp[i][j];
A[msk]++;
}
for (int i = 0; i < (1 << n); i++) {
int cnt = 0;
for (int j = 0; j < n; j++)
if (i & (1 << j)) cnt++;
B[i] = min(cnt, n - cnt);
}
fwt(A, 1 << n);
fwt(B, 1 << n);
for (int i = 0; i < (1 << n); i++) A[i] *= B[i];
ifwt(A, 1 << n);
long long ans = inf_ll;
for (int i = 0; i < (1 << n); i++) ans = min(ans, A[i]);
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const int M = 100100;
void FWT(long long *x, int n) {
if (n == 1) return;
int l = n >> 1;
FWT(x, l);
FWT(x + l, l);
for (int i = 0; i < l; i++) {
long long &u = x[i], &v = x[l + i];
long long uu = u, vv = v;
u = uu + vv;
v = uu - vv;
}
}
void IFWT(long long *x, int n) {
if (n == 1) return;
int l = n >> 1;
for (int i = 0; i < l; i++) {
long long &u = x[i], &v = x[l + i];
long long uu = u, vv = v;
u = (uu + vv) >> 1;
v = (uu - vv) >> 1;
}
IFWT(x, l);
IFWT(x + l, l);
}
int n, m;
char s[N][M] = {'\0'};
long long a[1 << N] = {0}, b[1 << N] = {0};
int pc(int x) { return x ? pc(x & (x - 1)) + 1 : 0; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char &ch = s[i][j];
do {
ch = getchar();
} while (!isdigit(ch));
}
}
for (int i = 0; i < m; i++) {
int c = 0;
for (int j = 0; j < n; j++) {
c = (c << 1) | (s[j][i] ^ '0');
}
a[c]++;
}
int x = 1 << n;
for (int j = 0; j < x; j++) {
b[j] = min(pc(j), pc((x - 1) ^ j));
}
FWT(a, x);
FWT(b, x);
for (int i = 0; i < x; i++) {
a[i] *= b[i];
}
IFWT(a, x);
int ans = INT_MAX;
for (int i = 0; i < x; i++) {
ans = min(ans, (int)a[i]);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int MN = 1100000 + 5, P = 998244353, inv2 = 499122177;
using namespace std;
template <typename T>
inline T &IN(T &in) {
in = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) in = in * 10 + c - '0', c = getchar();
return in *= f;
}
int n, m, N;
long long ans;
char s[MN];
long long a[MN], b[MN], c[MN], w[MN];
void fwt(long long *a, int n, int f) {
for (int i = 2; i <= n; i <<= 1)
for (int j = 0, d = i / 2; j < n; j += i)
for (int k = 0; k < d; ++k) {
long long x = a[j + k], y = a[j + k + d];
a[j + k] = (x + y) % P, a[j + k + d] = (x - y + P) % P;
if (f == -1)
a[j + k] = a[j + k] * inv2 % P,
a[j + k + d] = a[j + k + d] * inv2 % P;
}
}
void input() {
IN(n), IN(m);
N = 1 << n;
for (int i = 1; i <= n; ++i) {
scanf("%s", s + 1);
for (int j = 1; j <= m; ++j) c[j] += (s[j] - '0') << i - 1;
}
for (int i = 1; i <= m; ++i) a[c[i]]++;
for (int i = 0; i < N; ++i) b[i] = b[i >> 1] + (i & 1);
for (int i = 0; i < N; ++i) b[i] = min(b[i], n - b[i]);
fwt(a, N, 1), fwt(b, N, 1);
for (int i = 0; i < N; ++i) c[i] = a[i] * b[i] % P;
fwt(c, N, -1);
ans = LLONG_MAX;
for (int i = 0; i < N; ++i) ans = min(ans, c[i]);
printf("%lld\n", ans);
}
int main() {
input();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c;
do c = getchar(), f = c == '-' ? -1 : f;
while (!isdigit(c));
do x = (x << 3) + (x << 1) + c - '0', c = getchar();
while (isdigit(c));
return x * f;
}
int n, m, p;
long long tmp;
long long f[2000050], a[2000050], b[2000050], ans[2000050], g[2000050];
inline void fwt(long long *a, int mode) {
for (int i = 2; i <= p + 1; i <<= 1) {
int mid = i >> 1;
for (int j = 0; j <= p + 1; j += i) {
for (int k = j; k < j + mid; k++) {
long long x = a[k], y = a[k + mid];
if (mode == 1)
a[k] = x + y, a[k + mid] = x - y;
else
a[k] = (x + y) / 2, a[k + mid] = (x - y) / 2;
}
}
}
}
char s[2000050];
int main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (int j = 1; j <= m; j++) a[j] = (a[j] << 1) + (s[j] == '1');
}
p = (1 << n) - 1;
for (int i = 1; i <= p; i++) f[i] = f[i >> 1] + (i & 1);
for (int i = 1; i <= m; i++) b[a[i]]++;
for (int i = 1; i <= p; i++) g[i] = min(f[i], n - f[i]);
fwt(g, 1);
fwt(b, 1);
for (int i = 0; i <= p; i++) ans[i] = g[i] * b[i];
fwt(ans, 0);
tmp = 2147483647;
for (int i = 0; i <= p; i++) tmp = min(tmp, ans[i]);
printf("%lld", tmp);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return a > val ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
const int maxn = 20;
const int maxm = 100010;
int n, m;
int a[maxn][maxm];
long long f[1 << maxn];
long long g[1 << maxn];
void XORFFT(long long a[], int n, int invert) {
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j += i << 1) {
for (int k = 0; k < i; k++) {
long long u = a[j + k], v = a[i + j + k];
a[j + k] = u + v;
a[i + j + k] = u - v;
}
}
}
if (invert) {
for (int i = 0; i < n; i++) a[i] /= n;
}
}
void solve() {
cin >> n >> m;
for (int i = (0); i < (n); i++) {
string s;
cin >> s;
for (int j = (0); j < (m); j++) a[i][j] = s[j] - '0';
}
for (int i = (0); i < (1 << n); i++) {
f[i] = __builtin_popcountll(i);
chkmin(f[i], n - f[i]);
}
for (int i = (0); i < (m); i++) {
int t = 0;
for (int j = (0); j < (n); j++) t = (t << 1) + a[j][i];
g[t]++;
}
XORFFT(f, 1 << n, 0);
XORFFT(g, 1 << n, 0);
for (int i = (0); i < (1 << n); i++) f[i] *= g[i];
XORFFT(f, 1 << n, 1);
int ans = INF;
for (int i = (0); i < (1 << n); i++) {
chkmin(ans, (int)f[i]);
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, t;
char S[25][100005];
long long f[1048576], dp[1048576];
int ans;
inline void Read(int &p) {
p = 0;
char c = getchar();
for (; c < '0' || c > '9'; c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar()) p = p * 10 + c - '0';
}
inline void XorFWT(int n, long long *A) {
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j += (i << 1)) {
for (int k = 0; k < i; k++) {
long long x = A[j + k] + A[j + k + i];
long long y = A[j + k] - A[j + k + i];
A[j + k] = x, A[j + k + i] = y;
}
}
}
}
inline void XorIFWT(int n, long long *A) {
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j += (i << 1)) {
for (int k = 0; k < i; k++) {
long long x = A[j + k] + A[j + k + i];
long long y = A[j + k] - A[j + k + i];
A[j + k] = x / 2;
A[j + k + i] = y / 2;
}
}
}
}
inline void mul(long long *A, long long *B, int w) {
for (int i = 0; i < w; i++) A[i] = A[i] * B[i];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", S[i] + 1);
for (int i = 1; i <= m; i++) {
int v = 0;
for (int j = 1; j <= n; j++) v = v * 2 + S[j][i] - '0';
f[v]++;
}
for (int i = 1; i < (1 << n); i++) dp[i] = dp[i - (i & -i)] + 1;
for (int i = 0; i < (1 << n); i++) dp[i] = min(dp[i], n - dp[i]);
XorFWT(1 << n, f);
XorFWT(1 << n, dp);
mul(f, dp, 1 << n);
XorIFWT(1 << n, f);
ans = n * m;
for (int i = 0; i < (1 << n); i++) ans = min(ans, int(f[i]));
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
namespace Dango {
const int MAXN = 25, MAXM = 100005;
string st;
int n, m;
int num[MAXM];
int dp[MAXN][(1 << 20) + 5];
int ans;
int work() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> st;
for (int j = 0; j < st.length(); j++)
num[j + 1] = (num[j + 1] << 1) + (st[j] - '0');
}
for (int i = 1; i <= m; i++) dp[0][num[i]]++;
for (int i = 0; i < n; i++)
for (int j = n; j >= 1; j--)
for (int k = 0; k < (1 << n); k++) dp[j][k] += dp[j - 1][k ^ (1 << i)];
ans = n * m;
for (int i = 0; i < (1 << n); i++) {
int res = 0;
for (int j = 0; j <= n; j++) res += dp[j][i] * min(j, n - j);
ans = min(ans, res);
}
cout << ans;
return 0;
}
} // namespace Dango
int main() { return Dango::work(); }
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 21) + 10;
long long a[N], b[N], tp[N];
void dft(long long *a, int l, int r, long long *b) {
int mid = (l + r) >> 1;
if (l == r) return;
dft(a, l, mid, b);
dft(a, mid + 1, r, b);
for (int x = l, y = mid + 1; x <= mid; x++, y++) {
b[x] = a[x] + a[y];
b[y] = a[x] - a[y];
}
for (int i = l; i <= r; i++) a[i] = b[i];
}
int c[N];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
char ch;
int x = 0;
for (int j = 1; j <= m; j++) {
while (scanf("%c", &ch), ch != '0' && ch != '1')
;
c[j] = c[j] * 2 + ch - '0';
}
}
for (int i = 1; i <= m; i++) a[c[i]]++;
swap(n, m);
for (int i = 0; i <= (1 << m) - 1; i++) {
for (int j = i; j; j ^= j & -j) b[i]++;
b[i] = min(b[i], m - b[i]);
}
dft(a, 0, (1 << m) - 1, tp);
dft(b, 0, (1 << m) - 1, tp);
for (int i = 0; i <= (1 << m) - 1; i++) a[i] = a[i] * b[i];
dft(a, 0, (1 << m) - 1, tp);
long long mi = 1e18;
for (int i = 0; i <= (1 << m) - 1; i++) mi = min(mi, a[i]);
cout << (mi >> m);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 21;
const long long M = 100005;
long long a[1 << N];
long long b[1 << N];
char ss[N][M];
long long n, nn, m;
void FWT(long long *a, long long n, long long o) {
for (long long u = 2; u <= n; u <<= 1) {
long long p = (u >> 1);
for (long long i = 0; i < n; i = i + u)
for (long long j = i; j < i + p; j++) {
long long x = a[j], y = a[j + p];
a[j] = x + y;
a[j + p] = x - y;
if (o == -1) {
a[j] /= 2;
a[j + p] /= 2;
}
}
}
}
int main() {
scanf("%lld%lld", &n, &m);
nn = (1 << n);
for (long long u = 1; u <= n; u++) scanf("%s", ss[u] + 1);
for (long long u = 1; u <= m; u++) {
long long now = 0;
for (long long i = 1; i <= n; i++) now = ((now << 1) + ss[i][u] - '0');
a[now]++;
}
b[0] = 0;
for (long long u = 1; u < nn; u++) b[u] = b[u >> 1] + (u & 1);
for (long long u = 0; u < nn; u++) b[u] = min(b[u], n - b[u]);
FWT(a, nn, 1);
FWT(b, nn, 1);
for (long long u = 0; u < nn; u++) a[u] = a[u] * b[u];
FWT(a, nn, -1);
long long ans = n * m;
for (long long u = 0; u < nn; u++) ans = min(ans, a[u]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
const int maxn = 1 << 21;
long long a[maxn], b[maxn], col[maxn];
int n, m;
char str[200001];
void TransForm(int l, int r, long long a[]) {
if (l == r - 1) return;
int len = (r - l) >> 1;
int m = l + len;
TransForm(l, m, a);
TransForm(m, r, a);
for (int i = l; i < m; i++) {
long long a0 = a[i];
long long a1 = a[i + len];
a[i] = a0 - a1;
a[i + len] = a0 + a1;
}
}
void uTransForm(int l, int r, long long a[]) {
if (l == r - 1) return;
int len = (r - l) >> 1;
int m = l + len;
for (int i = l; i < m; i++) {
long long AERGAEWFAWERAw = a[i];
long long ASDFAEWRWERWERW = a[i + len];
a[i] = (AERGAEWFAWERAw + ASDFAEWRWERWERW) / 2;
a[i + len] = (ASDFAEWRWERWERW - AERGAEWFAWERAw) / 2;
}
uTransForm(l, m, a);
uTransForm(m, r, a);
}
void Conv(long long a[], long long b[], int len) {
TransForm(0, len, a);
TransForm(0, len, b);
for (int i = 0; i < len; i++) a[i] = a[i] * b[i];
uTransForm(0, len, a);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < 1 << n; i++) {
b[i] = __builtin_popcount(i);
b[i] = min(b[i], n - b[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%s", str);
for (int j = 0; j < m; j++)
if (str[j] == '1') col[j] |= (1 << (i - 1));
}
for (int j = 0; j < m; j++) a[col[j]]++;
TransForm(0, 1 << n, a);
TransForm(0, 1 << n, b);
for (int i = 0; i < 1 << n; i++) a[i] = a[i] * b[i];
uTransForm(0, 1 << n, a);
long long ans = a[0];
for (int i = 1; i < 1 << n; i++) ans = min(ans, a[i]);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 1048576;
int n, m, len;
long long a[mxn], b[mxn], ans;
char s[21][131072];
void FWT(long long *a, bool flg) {
for (int i = 1; i <= len >> 1; i <<= 1)
for (int j = 0; j < len; j += i << 1)
for (int k = j; k < j + i; ++k) {
long long x = a[k], y = a[k + i];
a[k] = x + y, a[k + i] = x - y;
if (flg) a[k] /= 2, a[k + i] /= 2;
}
}
int main() {
scanf("%d%d", &n, &m), len = 1 << n, ans = n * m;
for (int i = 1; i <= n; ++i) scanf("%s", s[i]);
for (int i = 0; i < m; ++i) {
int num = 0;
for (int j = 1; j <= n; ++j) num |= (s[j][i] - 48) << (j - 1);
++a[num];
}
for (int i = 0; i < len; ++i) {
for (int j = 0; j < n; ++j) b[i] += (i & (1 << j)) != 0;
b[i] = min(b[i], n - b[i]);
}
FWT(a, 0), FWT(b, 0);
for (int i = 0; i < len; ++i) a[i] *= b[i];
FWT(a, 1);
for (int i = 0; i < len; ++i) ans = min(ans, a[i]);
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[20][100005];
long long dp[1 << 20];
int tmp[1 << 20];
int main() {
int n, m;
{
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf(" %s", str[i]);
for (int j = 0; j < m; j++) {
int val = 0;
for (int i = 0; i < n; i++) {
if (str[i][j] == '1') {
val |= 1 << i;
}
}
dp[val]++;
}
}
for (int i = 0; i < (1 << n); i++) {
tmp[i] = __builtin_popcount(i);
tmp[i] = min(tmp[i], n - tmp[i]);
}
for (int b = 1; b < (1 << n); b *= 2) {
for (int st = 0; st < (1 << n); st += 2 * b) {
for (int i = 0; i < b; i++) {
{
auto a0 = dp[st + i];
auto a1 = dp[st + i + b];
dp[st + i] = a0 + a1;
dp[st + i + b] = a0 - a1;
}
{
auto a0 = tmp[st + i];
auto a1 = tmp[st + i + b];
tmp[st + i] = a0 + a1;
tmp[st + i + b] = a0 - a1;
}
}
}
}
for (int i = 0; i < (1 << n); i++) {
dp[i] *= tmp[i];
}
for (int b = 1; b < (1 << n); b *= 2) {
for (int st = 0; st < (1 << n); st += 2 * b) {
for (int i = 0; i < b; i++) {
auto a0 = dp[st + i];
auto a1 = dp[st + i + b];
dp[st + i] = (-a0 - a1) / -2;
dp[st + i + b] = (-a0 + a1) / -2;
}
}
}
int ans = int(1e9);
for (int i = 0; i < (1 << n); i++) {
ans = min(ans, (int)dp[i]);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60777216")
using namespace std;
int n, m;
int a[111111];
int a1[111111];
int a2[111111];
int nb[1 << 13];
const int N1 = 13;
int c[N1 + 1][1 << (20 - N1)];
int main() {
cin >> n >> m;
string s;
getline(cin, s);
for (int i = (0); i < (n); i++) {
getline(cin, s);
for (int j = (0); j < (m); j++)
if (s[j] == '1') a[j] |= 1 << i;
}
for (int i = (0); i < (1 << 13); i++) nb[i] = nb[i / 2] + i % 2;
int n1 = min(n, N1);
int fn1 = (1 << n1) - 1;
int n2 = n - n1;
int t, sum, v;
int best = n * m;
for (int i = (0); i < (m); i++) a1[i] = a[i] & fn1, a2[i] = a[i] >> n1;
for (int m1 = (0); m1 < (1 << n1); m1++) {
memset(c, 0, sizeof c);
for (int j = (0); j < (m); j++) c[nb[a1[j] ^ m1]][a2[j]]++;
for (int m2 = (0); m2 < (1 << n2); m2++) {
sum = 0;
for (int fnb = (0); fnb < (n1 + 1); fnb++)
for (int fm2 = (0); fm2 < (1 << n2); fm2++)
if (v = c[fnb][fm2]) {
t = fnb + nb[fm2 ^ m2];
sum += v * min(n - t, t);
}
best = min(best, sum);
}
}
cout << best << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &digit) {
digit = 0;
char c;
for (c = getchar(); (c < '0' || c > '9') && c != '-'; c = getchar())
;
bool type = false;
if (c == '-') type = true, c = getchar();
for (; c >= '0' && c <= '9'; digit = digit * 10 + c - '0', c = getchar())
;
if (type == true) digit = -digit;
}
int b[100010];
long long f[1048576], g[1048576], c[1048576];
int n, m, all;
void cheng(long long *c, long long *a, long long *b, int n) {
if (n == 1) {
c[0] = a[0] * b[0];
return;
}
long long A[n], B[n], C[n], D[n];
for (int i = 0; i < n / 2; i++) A[i] = a[i] + a[i + n / 2];
for (int i = 0; i < n / 2; i++) B[i] = b[i] + b[i + n / 2];
cheng(C, A, B, n / 2);
for (int i = 0; i < n / 2; i++) A[i] = a[i] - a[i + n / 2];
for (int i = 0; i < n / 2; i++) B[i] = b[i] - b[i + n / 2];
cheng(D, A, B, n / 2);
for (int i = 0; i < n / 2; i++) c[i] = (C[i] + D[i]) / 2;
for (int i = 0; i < n / 2; i++) c[i + n / 2] = (C[i] - D[i]) / 2;
}
long long mjy;
int main() {
read(n);
read(m);
mjy = n * m;
for (int i = n; i >= 1; i--)
for (int j = 1; j <= m; j++) {
char ch = getchar();
while (ch != '0' && ch != '1') ch = getchar();
if (ch == '1') b[j] += 1 << (i - 1);
}
all = 1 << n;
for (int i = 1; i <= m; i++) f[b[i]]++;
for (int i = 0; i < all; i++) {
int q = __builtin_popcount(i);
g[i] = min(q, n - q);
}
n = all;
cheng(c, f, g, n);
for (int i = 0; i < n; i++) mjy = min(mjy, c[i]);
cout << mjy << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f = ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return f ? -x : x;
}
const int N = 1 << 20;
int k, n;
int a[N];
long long c[N];
long long d[N][21];
int main() {
k = read(), n = read();
for (int i = (0); i <= (k - 1); i++)
for (int j = (1); j <= (n); j++) {
int x;
scanf("%1d", &x);
a[j] |= x << i;
}
for (int i = (1); i <= (n); i++) c[a[i]]++;
int m = (1 << k) - 1;
for (int i = (0); i <= (m); i++) d[i][__builtin_popcount(i)] = 1;
for (int i = (0); i <= (k - 1); i++)
for (int j = (0); j <= (m); j++)
if (~j >> i & 1) {
{
long long x = c[j], y = c[j | 1 << i];
c[j] = x + y, c[j | 1 << i] = x - y;
}
{
for (int t = (0); t <= (k); t++) {
long long x = d[j][t], y = d[j | 1 << i][t];
d[j][t] = x + y, d[j | 1 << i][t] = x - y;
}
}
}
for (int i = (0); i <= (m); i++)
for (int j = (0); j <= (k); j++) d[i][j] *= c[i];
for (int i = (0); i <= (k - 1); i++)
for (int j = (0); j <= (m); j++)
if (~j >> i & 1) {
for (int t = (0); t <= (k); t++) {
long long x = d[j][t], y = d[j | 1 << i][t];
d[j][t] = (x + y) / 2, d[j | 1 << i][t] = (x - y) / 2;
}
}
int ans = 1e9;
for (int i = (0); i <= (m); i++) {
int now = 0;
long long sum = 0;
for (int j = (0); j <= (k); j++) {
sum += d[i][j];
now += min(j, k - j) * d[i][j];
}
ans = min(ans, now);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
struct FastWalshHadamardTransform {
void dwt(long long* a, int n) {
for (int d = 1; d < n; d <<= 1) {
for (int m = d << 1, i = 0; i < n; i += m) {
for (int j = 0; j < d; ++j) {
long long x = a[i + j], y = a[i + j + d];
a[i + j] = x + y, a[i + j + d] = x - y;
}
}
}
}
void idwt(long long* a, int n) {
for (int d = 1; d < n; d <<= 1) {
for (int m = d << 1, i = 0; i < n; i += m) {
for (int j = 0; j < d; ++j) {
long long x = a[i + j], y = a[i + j + d];
a[i + j] = (x + y) >> 1, a[i + j + d] = (x - y) >> 1;
}
}
}
}
void main(long long* a, long long* b, long long* res, int n) {
dwt(a, n);
dwt(b, n);
for (int i = 0; i < n; ++i) res[i] = a[i] * b[i];
idwt(res, n);
}
} fwt;
const int L = 1 << 22;
char mat[22][100010];
long long a[L], b[L], c[L];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", mat[i]);
for (int i = 0; i < m; ++i) {
int state(0);
for (int j = 0; j < n; ++j) state |= (mat[j][i] == '1') << j;
++a[state];
}
for (int i = 0, lim = 1 << n; i < lim; ++i) {
b[i] = std ::min(__builtin_popcount(i), n - __builtin_popcount(i));
}
fwt.main(a, b, c, 1 << n);
std ::cout << *std ::min_element(c, c + (1 << n)) << std ::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1 << 22], b[1 << 22];
const int mod = 998244353;
long long qpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) {
res = res * a % mod;
}
b >>= 1;
a = a * a % mod;
}
return res;
}
struct FWT {
int mod = 998244353;
int rev = qpow(2, mod - 2);
int add(int a, int b) {
if (a + b >= mod) return a + b - mod;
if (a + b < 0) return a + b + mod;
return a + b;
}
int mul(int a, int b) { return (long long)a * b % mod; }
void fwt(int a[], int n, int op) {
for (int d = 1; d < n; d <<= 1) {
for (int m = d << 1, i = 0; i < n; i += m) {
for (int j = 0; j < d; j++) {
int x = a[i + j], y = a[i + j + d];
if (op == 0)
a[i + j] = add(x, y), a[i + j + d] = add(x, -y);
else
a[i + j] = mul(add(x, y), rev), a[i + j + d] = mul(add(x, -y), rev);
}
}
}
}
void solve(int a[], int b[], int n) {
fwt(a, n, 0);
fwt(b, n, 0);
for (int i = (0); i < (n); i++) a[i] = mul(a[i], b[i]);
fwt(a, n, 1);
}
} Fwt;
char maze[25][100000 + 10];
int get(int x, int n) {
int cnt = 0;
while (x) {
if (x % 2 == 1) cnt++;
x /= 2;
}
return min(cnt, n - cnt);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) cin >> maze[i][j];
}
for (int i = (0); i < (m); i++) {
int sta = 0;
for (int j = (0); j < (n); j++)
if (maze[j][i] == '1') sta |= (1 << j);
a[sta]++;
}
for (int i = (0); i < (1 << n); i++) {
b[i] = get(i, n);
}
Fwt.solve(a, b, 1 << n);
int ans = 1e9;
for (int i = (0); i < (1 << n); i++) {
ans = min(ans, a[i]);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
clock_t __t = clock();
namespace my_std {
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
inline T rnd(T l, T r) {
return uniform_int_distribution<T>(l, r)(rng);
}
template <typename T>
inline bool chkmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
template <typename T>
inline bool chkmin(T &x, T y) {
return x > y ? x = y, 1 : 0;
}
template <typename T>
inline void read(T &t) {
t = 0;
char f = 0, ch = getchar();
double d = 0.1;
while (ch > '9' || ch < '0') f |= (ch == '-'), ch = getchar();
while (ch <= '9' && ch >= '0') t = t * 10 + ch - 48, ch = getchar();
if (ch == '.') {
ch = getchar();
while (ch <= '9' && ch >= '0') t += d * (ch ^ 48), d *= 0.1, ch = getchar();
}
t = (f ? -t : t);
}
template <typename T, typename... Args>
inline void read(T &t, Args &...args) {
read(t);
read(args...);
}
char __sr[1 << 21], __z[20];
int __C = -1, __zz = 0;
inline void Ot() { fwrite(__sr, 1, __C + 1, stdout), __C = -1; }
inline void print(int x) {
if (__C > 1 << 20) Ot();
if (x < 0) __sr[++__C] = '-', x = -x;
while (__z[++__zz] = x % 10 + 48, x /= 10)
;
while (__sr[++__C] = __z[__zz], --__zz)
;
__sr[++__C] = '\n';
}
void file() {}
inline void chktime() {}
long long ksm(long long x, int y) {
long long ret = 1;
for (; y; y >>= 1, x = x * x)
if (y & 1) ret = ret * x;
return ret;
}
} // namespace my_std
using namespace my_std;
int n, m;
char a[20][1100000];
long long c[1100000], w[1100000];
void FWT(long long *a) {
long long x, y;
for (int i = (0); i <= (n - 1); i++)
for (int j = (0); j <= ((1 << n) - 1); j++)
if (j >> i & 1)
x = a[1 << i ^ j], y = a[j], a[1 << i ^ j] = x + y, a[j] = x - y;
}
void iFWT(long long *a) {
long long x, y;
for (int i = (0); i <= (n - 1); i++)
for (int j = (0); j <= ((1 << n) - 1); j++)
if (j >> i & 1)
x = a[1 << i ^ j], y = a[j], a[1 << i ^ j] = x + y, a[j] = x - y;
for (int j = (0); j <= ((1 << n) - 1); j++) a[j] >>= n;
}
int main() {
file();
read(n, m);
for (int i = (0); i <= (n - 1); i++) cin >> (a[i] + 1);
for (int j = (1); j <= (m); j++) {
int x = 0;
for (int i = (0); i <= (n - 1); i++) x += int(a[i][j] - '0') << i;
++c[x];
}
for (int i = (0); i <= ((1 << n) - 1); i++)
w[i] = min(__builtin_popcount(i), n - __builtin_popcount(i));
FWT(c), FWT(w);
for (int i = (0); i <= ((1 << n) - 1); i++) w[i] = w[i] * c[i];
iFWT(w);
long long ans = n * m;
for (int i = (0); i <= ((1 << n) - 1); i++) chkmin(ans, w[i]);
cout << ans;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.