text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos((long double)-1.0);
const double EPS = 1e-10;
const int MOD = 1e9 + 7;
template <typename T>
void cmin(T &x, T y) {
if (y < x) x = y;
}
template <typename T>
void cmax(T &x, T y) {
if (y > x) x = y;
}
long long qpow(long long x, long long n, long long mod = MOD) {
if (n < 0) return 0;
long long res = 1;
while (n) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
long long sq(long long x) { return x * x; }
long long read() {
long long res = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) {
res = res * 10 + (c - '0');
c = getchar();
}
return res;
}
const int MAXN = 200000 + 10;
int n;
int a[MAXN];
int pos[MAXN];
struct SegmentTree {
int cnt[MAXN << 2];
long long sum[MAXN << 2];
int add[MAXN << 2];
void PushUp(int o) {
cnt[o] = cnt[(o << 1)] + cnt[(o << 1 | 1)];
sum[o] = sum[(o << 1)] + sum[(o << 1 | 1)];
}
void PushDown(int o, int l, int r) {
if (add[o]) {
int m = (l + r) >> 1;
sum[(o << 1)] += 1LL * cnt[(o << 1)] * add[o];
sum[(o << 1 | 1)] += 1LL * cnt[(o << 1 | 1)] * add[o];
add[(o << 1)] += add[o];
add[(o << 1 | 1)] += add[o];
add[o] = 0;
}
}
void Build(int o, int l, int r) {
add[o] = 0;
if (l == r) {
cnt[o] = 1;
sum[o] = 0;
return;
}
int m = (l + r) >> 1;
Build((o << 1), l, m);
Build((o << 1 | 1), m + 1, r);
PushUp(o);
}
void Add(int o, int l, int r, int ql, int qr, int v) {
if (ql <= l && r <= qr) {
sum[o] += 1LL * cnt[o] * v;
add[o] += v;
return;
}
PushDown(o, l, r);
int m = (l + r) >> 1;
if (ql <= m) Add((o << 1), l, m, ql, qr, v);
if (qr >= m + 1) Add((o << 1 | 1), m + 1, r, ql, qr, v);
PushUp(o);
}
void SetCnt0(int o, int l, int r, int p) {
if (l == r) {
cnt[o] = 0;
sum[o] = 0;
return;
}
PushDown(o, l, r);
int m = (l + r) >> 1;
if (p <= m) SetCnt0((o << 1), l, m, p);
if (p >= m + 1) SetCnt0((o << 1 | 1), m + 1, r, p);
PushUp(o);
}
int Cnt(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return cnt[o];
PushDown(o, l, r);
int m = (l + r) >> 1;
int res = 0;
if (ql <= m) res = res + Cnt((o << 1), l, m, ql, qr);
if (qr >= m + 1) res = res + Cnt((o << 1 | 1), m + 1, r, ql, qr);
return res;
}
long long Sum(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return sum[o];
PushDown(o, l, r);
int m = (l + r) >> 1;
long long res = 0;
if (ql <= m) res = res + Sum((o << 1), l, m, ql, qr);
if (qr >= m + 1) res = res + Sum((o << 1 | 1), m + 1, r, ql, qr);
return res;
}
int Pos(int o, int l, int r, int k) {
if (l == r) return l;
PushDown(o, l, r);
int m = (l + r) >> 1;
int cnt0ls = (m - l + 1) - cnt[(o << 1)];
if (cnt0ls >= k) return Pos((o << 1), l, m, k);
return Pos((o << 1 | 1), m + 1, r, k - cnt0ls);
}
int Lmid() {
int cnt0 = n - cnt[1];
return Pos(1, 1, n, (cnt0 + 1) / 2);
}
int Rmid() {
int cnt0 = n - cnt[1];
return Pos(1, 1, n, cnt0 / 2 + 1);
}
} st;
namespace Solver {
void InitOnce() { int t; }
void Read() {
int res = scanf("%d", &n);
if (res == -1) exit(0);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
}
long long ans[200005];
void Solve() {
st.Build(1, 1, n);
long long cur = 0;
int Lmost = n, Rmost = 1;
for (int i = 1; i <= n; ++i) {
int p = pos[i];
cmin(Lmost, p);
cmax(Rmost, p);
cur += (n - p + 1) - st.Cnt(1, 1, n, p, n);
if (i >= 2) {
int Lmid = st.Lmid();
int Rmid = st.Rmid();
if (p < Lmid) st.Add(1, 1, n, p, Lmid, 1);
if (p > Rmid) st.Add(1, 1, n, Rmid, p, 1);
}
st.SetCnt0(1, 1, n, p);
ans[i] = cur + st.Sum(1, 1, n, Lmost, Rmost);
printf("%lld%c", ans[i], " \n"[i == n]);
}
}
} // namespace Solver
int main() {
Solver::InitOnce();
while (true) {
Solver::Read();
Solver::Solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int T, n, m, p, k, a[200010], pos[200010], bit[200010], hd;
long long ans = 0;
int query(int a) {
int tmp = 0;
for (int i = a; i >= 1; i -= (i & -i)) tmp += bit[i];
return tmp;
}
void add(int a, int x) {
for (int i = a; i <= n; i += (i & -i)) bit[i] += x;
}
set<int> S;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), pos[a[i]] = i;
S.insert(INT_MIN);
S.insert(INT_MAX);
hd = pos[1];
for (int i = 1; i <= n; i++) {
ans += query(n) - query(pos[i]);
add(pos[i], 1);
if (pos[i] < hd)
ans += hd - pos[i] - 1 - query(hd - 1) + query(pos[i]),
ans -= query(pos[i] - 1);
if (pos[i] > hd)
ans += pos[i] - hd - 1 - query(pos[i] - 1) + query(hd),
ans -= query(n) - query(pos[i]);
S.insert(pos[i]);
set<int>::iterator now = S.find(hd), l = now, r;
l--;
if ((*l) > 0) {
if (query(n) - query(*l) <= i / 2 && query((*l) - 1) <= i / 2)
ans += (hd - (*l) - 1) * (query(n) - 2 * query(hd - 1)), hd = *l;
}
now = S.find(hd), r = now;
r++;
if ((*r) <= n) {
if (query(n) - query(*r) <= i / 2 && query((*r) - 1) <= i / 2)
ans += ((*r) - hd - 1) * (2 * query(hd) - query(n)), hd = *r;
}
printf("%lld ", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxd = 4e5 + 10;
long long t1[maxd], t2[maxd], pos[maxd], a[maxd], n;
void add(long long* t, long long x, long long v) {
for (; x < maxd; x += (x & -x)) t[x] += v;
}
long long query(long long* t, long long x) {
long long ans = 0;
for (; x; x -= (x & -x)) ans += t[x];
return ans;
}
int solve(long long* t, int v) {
int i = 0;
for (int j = 19; j >= 0; j--)
if ((i | 1 << j) < maxd)
if (t[i | (1 << j)] <= v) v -= t[i |= (1 << j)];
return i;
}
int main() {
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
pos[a[i]] = i;
}
long long ans = 0ll;
for (int i = 1; i <= n; i++) {
int p = pos[i];
add(t1, p, 1);
ans += i - query(t1, p);
add(t2, p, p);
int mid = solve(t1, i / 2) + 1;
long long sum = 0;
long long aa = i / 2;
long long bb = i - i / 2 - 1;
sum += (long long)aa * mid - aa * (aa + 1) / 2 - query(t2, mid - 1);
sum += (query(t2, maxd - 1) - query(t2, mid)) - (long long)bb * mid -
1ll * bb * (bb + 1) / 2;
printf("%lld ", sum + ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
return (b == 0 ? a : gcd(b, a % b));
}
char vow[] = {'a', 'e', 'i', 'o', 'u'};
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
const int N = 4e5 + 30;
const long long int mod = -1e11;
int n;
int tx[N];
set<long long int> s;
long long int t1[4 * N], t2[4 * N], t3[4 * N];
long long int flag1[4 * N], flag2[4 * N], flag3[4 * N];
long long int inv;
void push(int nd) {
t1[nd] += flag1[nd];
flag1[nd * 2] += flag1[nd];
flag1[nd * 2 + 1] += flag1[nd];
flag1[nd] = 0;
t2[nd] += flag2[nd];
flag2[nd * 2] += flag2[nd];
flag2[nd * 2 + 1] += flag2[nd];
flag2[nd] = 0;
t3[nd] += flag3[nd];
flag3[nd * 2] += flag3[nd];
flag3[nd * 2 + 1] += flag3[nd];
flag3[nd] = 0;
}
void upd1(int ql, int qr, long long int v, int nl = 1, int nr = n, int nd = 1) {
push(nd);
if (ql > nr || qr < nl) return;
if (ql == nl && qr == nr) {
flag1[nd] += v;
push(nd);
return;
}
int mid = (nl + nr) / 2;
upd1(ql, min(mid, qr), v, nl, mid, nd * 2);
upd1(max(mid + 1, ql), qr, v, mid + 1, nr, nd * 2 + 1);
}
long long int qry1(int q, int nl = 1, int nr = n, int nd = 1) {
push(nd);
if (q > nr || q < nl) return 0;
if (nl == nr) {
return t1[nd];
}
int mid = (nl + nr) / 2;
return qry1(q, nl, mid, nd * 2) + qry1(q, mid + 1, nr, nd * 2 + 1);
}
void upd2(int ql, int qr, long long int v, int nl = 1, int nr = n, int nd = 1) {
push(nd);
if (ql > nr || qr < nl) return;
if (ql == nl && qr == nr) {
flag2[nd] += v;
push(nd);
return;
}
int mid = (nl + nr) / 2;
upd2(ql, min(mid, qr), v, nl, mid, nd * 2);
upd2(max(mid + 1, ql), qr, v, mid + 1, nr, nd * 2 + 1);
}
long long int qry2(int q, int nl = 1, int nr = n, int nd = 1) {
push(nd);
if (q > nr || q < nl) return 0;
if (nl == nr) {
return t2[nd];
}
int mid = (nl + nr) / 2;
return qry2(q, nl, mid, nd * 2) + qry2(q, mid + 1, nr, nd * 2 + 1);
}
void upd3(int ql, int qr, long long int v, int nl = 1, int nr = n, int nd = 1) {
push(nd);
if (ql > nr || qr < nl) return;
if (ql == nl && qr == nr) {
flag3[nd] += v;
push(nd);
return;
}
int mid = (nl + nr) / 2;
upd3(ql, min(mid, qr), v, nl, mid, nd * 2);
upd3(max(mid + 1, ql), qr, v, mid + 1, nr, nd * 2 + 1);
}
long long int qry3(int q, int nl = 1, int nr = n, int nd = 1) {
push(nd);
if (q > nr || q < nl) return 0;
if (nl == nr) {
return t3[nd];
}
int mid = (nl + nr) / 2;
return qry3(q, nl, mid, nd * 2) + qry3(q, mid + 1, nr, nd * 2 + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
;
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
tx[a] = i + 1;
}
for (int i = 1; i <= n; i++) {
upd2(tx[i], n, 1);
long long int l = 1, r = n, ind = 0;
while (l <= r) {
int mid = (l + r) / 2;
if (qry2(mid) >= (i + 1) / 2) {
ind = mid;
r = mid - 1;
} else
l = mid + 1;
}
long long int s = (i + 1) / 2;
long long int sum = s * ind - ((s - 1LL) * s) / 2LL;
if (tx[i] == 1)
upd1(tx[i], n, -tx[i]);
else {
upd1(1, tx[i] - 1, tx[i]);
upd1(tx[i], n, -tx[i]);
}
inv += qry3(tx[i]);
upd3(1, tx[i], 1);
long long int ans = inv + sum + qry1(ind);
ind += i - (i + 1LL) / 2LL;
sum = i * ind - ((i - 1LL) * 1LL * i) / 2LL - sum;
ans -= sum;
cout << ans << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 2e5 + 233;
int ch[maxn];
int a[maxn], n, p[maxn];
long long ans[maxn], sum[maxn];
void add(int x, int v) {
for (int i = x; i <= n; i += i & (-i)) ch[i] += v;
}
int query(int x) {
int sum = 0;
for (int i = x; i; i -= i & (-i)) sum += ch[i];
return sum;
}
void add_sum(int x, int v) {
for (int i = x; i <= n; i += i & (-i)) sum[i] += v;
}
long long query_sum(int x) {
long long res = 0;
for (int i = x; i; i -= i & (-i)) res += sum[i];
return res;
}
int cal(int n, int x) {
int t = query(x);
return min(t, n - t);
}
int find(int k) {
k--;
int x = 0;
for (int i = 20; i >= 0; i--)
if (x + (1 << i) <= n && ch[x + (1 << i)] <= k) {
x += 1 << i;
k -= ch[x];
}
return x + 1;
}
inline long long ari(int n) { return 1ll * n * (n + 1) / 2; }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), p[a[i]] = i;
for (int i = 1; i <= n; i++) {
int x = p[i];
ans[i] = ans[i - 1] + (i - 1 - query(x));
add(x, 1);
}
memset(ch, 0, sizeof(ch));
long long sum = 0;
for (int i = 1; i <= n; i++) {
int x = p[i];
add(x, 1);
add_sum(x, x);
sum += x;
int k = (i + 1) / 2;
long long c = find(k);
long long tmp = query_sum(c);
long long a = k * c - tmp - ari(k - 1);
long long b = (sum - tmp) - (i - k) * c - ari(i - k);
ans[i] += a + b;
}
for (int i = 1; i <= n; i++) printf("%I64d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 200000;
long long a[200005], pos[200005];
long long sum1[200005], sum2[200005];
void add(long long *sum1, long long x, long long val) {
while (x <= maxn) {
sum1[x] += val;
x += x & (-x);
}
}
long long sum(long long *sum1, long long pos) {
long long res = 0;
while (pos) {
res += sum1[pos];
pos -= pos & (-pos);
}
return res;
}
signed main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]] = i;
}
long long ans1 = 0, ans2 = 0;
for (long long i = 1; i <= n; i++) {
ans1 += i - 1 - sum(sum1, pos[i]);
add(sum1, pos[i], 1);
add(sum2, pos[i], pos[i]);
long long l = 1, r = n;
while (l < r) {
long long mid = l + r + 1 >> 1;
if (sum(sum1, mid) * 2 <= i) {
l = mid;
} else
r = mid - 1;
}
long long cnt = sum(sum1, l);
long long sum3 = sum(sum2, l);
ans2 = 0;
ans2 += cnt * l - sum3 - cnt * (cnt - 1) / 2;
cnt = i - cnt;
sum3 = sum(sum2, n) - sum(sum2, l);
ans2 += sum3 - cnt * (l + 1) - cnt * (cnt - 1) / 2;
cout << ans1 + ans2 << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using pii = pair<int, int>;
using vii = vector<pii>;
using ll = long long;
int solve();
int main(int argc, char* argv[]) {
::std::ios::sync_with_stdio(false);
::std::cin.tie(0);
::std::cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
struct Fenwick {
vector<int> b;
int n;
Fenwick(int n) : n(n) { b.resize(n + 1); }
void add(int i) {
while (i > 0 && i <= n) {
b[i]++;
i += i & (-i);
}
}
int rank(int i) const {
int res = 0;
for (; i > 0; i -= i & (-i)) res += b[i];
return res;
}
int at_rank(int k) const {
int l = 0, r = n + 1;
while (l < r) {
int m = (l + r) / 2;
if (k <= rank(m))
r = m;
else
l = m + 1;
}
return l;
}
};
int solve() {
int n;
cin >> n;
vector<int> pos(n);
Fenwick f(n + 1);
for (int i = 0; i < n; i++) {
int p;
cin >> p;
pos[p - 1] = i + 1;
}
long long a = 0;
for (int i = 0; i < n; i++) {
int p = pos[i];
f.add(p);
int r = f.rank(p);
int m = i / 2 + 1;
if (r <= m) {
m += i & 1;
a += f.at_rank(m) - p - m + i - r + 2;
} else {
a += p - f.at_rank(m) + m - r;
}
cout << a << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int N;
int position[maxn];
long long sum1[maxn << 2], sum2[maxn << 2];
void add(long long* bit, int pos, long long val) {
while (pos <= N) {
bit[pos] += val;
pos += pos & (-pos);
}
}
long long query(long long* bit, int pos) {
long long ret = 0;
while (pos) {
ret += bit[pos];
pos -= pos & (-pos);
}
return ret;
}
int search(long long* bit, int val) {
int l = 1, r = N, ret = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (query(bit, mid) < val) {
l = mid + 1;
} else {
ret = mid;
r = mid - 1;
}
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N;
for (int i = 1; i <= N; ++i) {
int p;
cin >> p;
position[p] = i;
}
long long cnt = 0;
for (int i = 1; i <= N; ++i) {
int p = position[i];
add(sum1, p, 1);
cnt += i - query(sum1, p);
add(sum2, p, p);
long long pos = search(sum1, i / 2 + 1);
long long sum = 0;
long long a = i / 2, b = i - a - 1;
sum += pos * a - a * (a + 1) / 2 - query(sum2, pos - 1);
sum += (query(sum2, N) - query(sum2, pos)) - b * pos - b * (b + 1) / 2;
cout << cnt + sum << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[300005], pos[300005];
int lowbit(int now) { return now & (-now); }
long long sum[5][300005];
void add(int flag, int now, int val) {
for (int i = now; i <= n; i += lowbit(i)) sum[flag][i] += val;
}
long long query(int flag, int now) {
long long ans = 0;
for (int i = now; i; i -= lowbit(i)) ans += sum[flag][i];
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), pos[a[i]] = i;
long long ans1 = 0;
for (int i = 1; i <= n; i++) {
ans1 += (i - 1 - query(1, pos[i]));
add(1, pos[i], 1);
add(2, pos[i], pos[i]);
int nl = 1, nr = n, ans = 1;
while (nl <= nr) {
if (query(1, ((nl + nr) >> 1)) * 2 <= i) {
ans = ((nl + nr) >> 1);
nl = ((nl + nr) >> 1) + 1;
} else
nr = ((nl + nr) >> 1) - 1;
}
long long cnt1 = query(1, ans), cnt2 = i - cnt1;
long long res1 =
ans * cnt1 - query(2, ans) - (1 + cnt1 - 1) * (cnt1 - 1) / 2;
long long res2 = (query(2, n) - query(2, ans)) - ((ans + 1) * cnt2) -
(cnt2) * (cnt2 - 1) / 2;
printf("%lld ", ans1 + res1 + res2);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos((long double)-1.0);
const double EPS = 1e-10;
const int MOD = 1e9 + 7;
template <typename T>
void cmin(T &x, T y) {
if (y < x) x = y;
}
template <typename T>
void cmax(T &x, T y) {
if (y > x) x = y;
}
long long qpow(long long x, long long n, long long mod = MOD) {
if (n < 0) return 0;
long long res = 1;
while (n) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
long long sq(long long x) { return x * x; }
long long read() {
long long res = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) {
res = res * 10 + (c - '0');
c = getchar();
}
return res;
}
const int MAXN = 200000 + 10;
int n;
int a[MAXN];
int pos[MAXN];
struct SegmentTree {
int cnt[MAXN << 2];
long long sum[MAXN << 2];
int add[MAXN << 2];
void PushUp(int o) {
cnt[o] = cnt[(o << 1)] + cnt[(o << 1 | 1)];
sum[o] = sum[(o << 1)] + sum[(o << 1 | 1)];
}
void PushDown(int o, int l, int r) {
if (add[o]) {
int m = (l + r) >> 1;
sum[(o << 1)] += 1LL * cnt[(o << 1)] * add[o];
sum[(o << 1 | 1)] += 1LL * cnt[(o << 1 | 1)] * add[o];
add[(o << 1)] += add[o];
add[(o << 1 | 1)] += add[o];
add[o] = 0;
}
}
void Build(int o, int l, int r) {
add[o] = 0;
if (l == r) {
cnt[o] = 1;
sum[o] = 0;
return;
}
int m = (l + r) >> 1;
Build((o << 1), l, m);
Build((o << 1 | 1), m + 1, r);
PushUp(o);
}
void Add(int o, int l, int r, int ql, int qr, int v) {
if (ql <= l && r <= qr) {
sum[o] += 1LL * cnt[o] * v;
add[o] += v;
return;
}
PushDown(o, l, r);
int m = (l + r) >> 1;
if (ql <= m) Add((o << 1), l, m, ql, qr, v);
if (qr >= m + 1) Add((o << 1 | 1), m + 1, r, ql, qr, v);
PushUp(o);
}
void SetCnt0(int o, int l, int r, int p) {
if (l == r) {
cnt[o] = 0;
sum[o] = 0;
return;
}
PushDown(o, l, r);
int m = (l + r) >> 1;
if (p <= m) SetCnt0((o << 1), l, m, p);
if (p >= m + 1) SetCnt0((o << 1 | 1), m + 1, r, p);
PushUp(o);
}
int Cnt(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return cnt[o];
PushDown(o, l, r);
int m = (l + r) >> 1;
int res = 0;
if (ql <= m) res = res + Cnt((o << 1), l, m, ql, qr);
if (qr >= m + 1) res = res + Cnt((o << 1 | 1), m + 1, r, ql, qr);
return res;
}
long long Sum(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return sum[o];
PushDown(o, l, r);
int m = (l + r) >> 1;
long long res = 0;
if (ql <= m) res = res + Sum((o << 1), l, m, ql, qr);
if (qr >= m + 1) res = res + Sum((o << 1 | 1), m + 1, r, ql, qr);
return res;
}
int Pos(int o, int l, int r, int k) {
if (l == r) return l;
PushDown(o, l, r);
int m = (l + r) >> 1;
int cnt0ls = (m - l + 1) - cnt[(o << 1)];
if (cnt0ls >= k) return Pos((o << 1), l, m, k);
return Pos((o << 1 | 1), m + 1, r, k - cnt0ls);
}
int Lmid() {
int cnt0 = n - cnt[1];
return Pos(1, 1, n, (cnt0 + 1) / 2);
}
int Rmid() {
int cnt0 = n - cnt[1];
return Pos(1, 1, n, cnt0 / 2 + 1);
}
} st;
namespace Solver {
void InitOnce() { int t; }
void Read() {
int res = scanf("%d", &n);
if (res == -1) exit(0);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
}
long long ans[200005];
void Solve() {
st.Build(1, 1, n);
long long cur = 0;
int Lmost = n, Rmost = 1;
for (int i = 1; i <= n; ++i) {
int p = pos[i];
cmin(Lmost, p);
cmax(Rmost, p);
cur += (n - p + 1) - st.Cnt(1, 1, n, p, n);
if (i >= 2) {
int Lmid = st.Lmid();
int Rmid = st.Rmid();
if (p < Lmid) st.Add(1, 1, n, p + 1, Lmid - 1, 1);
if (p > Rmid) st.Add(1, 1, n, Rmid + 1, p - 1, 1);
}
st.SetCnt0(1, 1, n, p);
ans[i] = cur + st.Sum(1, 1, n, Lmost, Rmost);
printf("%lld%c", ans[i], " \n"[i == n]);
}
}
} // namespace Solver
int main() {
Solver::InitOnce();
while (true) {
Solver::Read();
Solver::Solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
int n;
int a[MAXN];
int pos[MAXN];
struct BIT {
long long tree[MAXN];
BIT() {}
int LB(int x) { return x & -x; }
void Modify(int p, long long k) {
while (p <= n) {
tree[p] += k;
p += LB(p);
}
}
long long Query(int p) {
long long res = 0;
while (p >= 1) {
res += tree[p];
p -= LB(p);
}
return res;
}
int GetPos(long long sum) {
int l = 1, r = n, res = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (Query(mid) <= sum) {
res = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
return res;
}
} T1, T2;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]] = i;
}
long long cnt = 0;
for (int i = 1; i <= n; i++) {
int p = pos[i];
T1.Modify(p, 1);
cnt += (long long)i - T1.Query(p);
T2.Modify(p, p);
int midp = T1.GetPos(i >> 1) + 1;
long long tot = 0;
long long l = i / 2, r = i - i / 2 - 1;
tot += l * midp - l * (l + 1) / 2 - T2.Query(midp - 1);
tot += (T2.Query(n) - T2.Query(midp)) - r * midp - r * (r + 1) / 2;
cout << tot + cnt << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1061109567;
const long long LINF = 4557430888798830399ll;
const int MOD = 1000000007;
long long qpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
struct Treap {
static const int MAXN = 200000 + 5;
int ch[MAXN][2], dat[MAXN];
pair<int, int> val[MAXN];
int cnt[MAXN];
int siz[MAXN];
int tot, root;
inline void Init() {
tot = 0;
root = 0;
}
inline int NewNode(pair<int, int> v, int num) {
int id = ++tot;
ch[id][0] = ch[id][1] = 0;
dat[id] = rand();
val[id] = v;
cnt[id] = num;
siz[id] = num;
return id;
}
inline void PushUp(int id) {
siz[id] = siz[ch[id][0]] + siz[ch[id][1]] + cnt[id];
}
inline void Rotate(int &id, int d) {
int temp = ch[id][d ^ 1];
ch[id][d ^ 1] = ch[temp][d];
ch[temp][d] = id;
id = temp;
PushUp(ch[id][d]);
PushUp(id);
}
inline void Insert(int &id, pair<int, int> v, int num) {
if (!id)
id = NewNode(v, num);
else {
if (v == val[id])
cnt[id] += num;
else {
int d = val[id] > v ? 0 : 1;
Insert(ch[id][d], v, num);
if (dat[id] < dat[ch[id][d]]) Rotate(id, d ^ 1);
}
PushUp(id);
}
}
void Remove(int &id, pair<int, int> v, int num) {
if (!id)
return;
else {
if (v == val[id]) {
if (cnt[id] > num) {
cnt[id] -= num;
PushUp(id);
} else if (ch[id][0] || ch[id][1]) {
if (!ch[id][1] || dat[ch[id][0]] > dat[ch[id][1]])
Rotate(id, 1), Remove(ch[id][1], v, num);
else
Rotate(id, 0), Remove(ch[id][0], v, num);
PushUp(id);
} else
id = 0;
} else {
val[id] > v ? Remove(ch[id][0], v, num) : Remove(ch[id][1], v, num);
PushUp(id);
}
}
}
int GetRank(int id, pair<int, int> v) {
int res = 1;
while (id) {
if (val[id] > v)
id = ch[id][0];
else if (val[id] == v) {
res += siz[ch[id][0]];
break;
} else {
res += siz[ch[id][0]] + cnt[id];
id = ch[id][1];
}
}
return res;
}
pair<int, int> GetValue(int id, int rk) {
pair<int, int> res = {INF, INF};
while (id) {
if (siz[ch[id][0]] >= rk)
id = ch[id][0];
else if (siz[ch[id][0]] + cnt[id] >= rk) {
res = val[id];
break;
} else {
rk -= siz[ch[id][0]] + cnt[id];
id = ch[id][1];
}
}
return res;
}
} treap1, treap2;
int n;
int a[200005];
int p[200005];
long long ans[200005];
void test_case() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
p[a[i]] = i;
}
treap1.Init();
treap2.Init();
int Lmost = p[1], Rmost = p[1];
long long cnt1 = 0, cnt2 = 0;
treap1.Insert(treap1.root, {p[1], 1}, 1);
treap2.Insert(treap2.root, {p[1], 1}, 1);
pair<int, int> mid1, mid2;
mid1 = mid2 = {p[1], 1};
ans[1] = 0;
for (int i = 2; i <= n; ++i) {
treap1.Insert(treap1.root, {p[i], i}, 1);
if (i % 2 == 0) {
mid1 = treap1.GetValue(treap1.root, i / 2);
mid2 = treap1.GetValue(treap1.root, i / 2 + 1);
} else
mid1 = mid2 = treap1.GetValue(treap1.root, (i + 1) / 2);
int rk1 = treap1.GetRank(treap1.root, {p[i], i});
if (p[i] < Lmost) {
for (int j = Lmost - 1; j >= p[i]; --j)
treap2.Insert(treap2.root, {j, a[j]}, 1);
Lmost = p[i];
cnt2 += treap2.GetRank(treap2.root, mid2) - 1 - i / 2;
} else if (p[i] > Rmost) {
for (int j = Rmost + 1; j <= p[i]; ++j)
treap2.Insert(treap2.root, {j, a[j]}, 1);
Rmost = p[i];
cnt2 +=
treap2.siz[treap2.root] - treap2.GetRank(treap2.root, mid1) - i / 2;
} else {
if (p[i] >= mid2.first) {
cnt2 -= i - rk1;
cnt2 -= treap2.siz[treap2.root] -
treap2.GetRank(treap2.root, {p[i], i}) - (i - rk1);
cnt2 +=
treap2.siz[treap2.root] - treap2.GetRank(treap2.root, mid1) - i / 2;
} else if (p[i] <= mid1.first) {
cnt2 -= rk1 - 1;
cnt2 -= treap2.GetRank(treap2.root, {p[i], i}) - (rk1 - 1);
cnt2 += treap2.GetRank(treap2.root, mid2) - i / 2;
}
}
cnt1 += i - rk1;
ans[i] = cnt1 + cnt2;
}
for (int i = 1; i <= n; ++i) printf("%lld%c", ans[i], " \n"[i == n]);
}
int main() {
int t = 1;
for (int ti = 1; ti <= t; ++ti) {
test_case();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1061109567;
const long long LINF = 4557430888798830399ll;
const int MOD = 1000000007;
long long qpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
struct TreapNode {
int val1, val2;
TreapNode() {}
TreapNode(int val1, int val2) : val1(val1), val2(val2) {}
bool operator<(const TreapNode& tn) const { return val1 < tn.val1; }
bool operator<=(const TreapNode& tn) const { return val1 <= tn.val1; }
bool operator==(const TreapNode& tn) const { return val1 == tn.val1; }
bool operator>=(const TreapNode& tn) const { return val1 >= tn.val1; }
bool operator>(const TreapNode& tn) const { return val1 > tn.val1; }
} TNINF(INF, INF);
struct Treap {
static const int MAXN = 200000;
int ch[MAXN + 5][2], dat[MAXN + 5];
TreapNode val[MAXN + 5];
int cnt[MAXN + 5];
int siz[MAXN + 5];
int tot, root;
void Init() {
tot = 0;
root = 0;
}
int NewNode(TreapNode v, int num) {
int id = ++tot;
ch[id][0] = ch[id][1] = 0;
dat[id] = rand();
val[id] = v;
cnt[id] = num;
siz[id] = num;
return id;
}
void PushUp(int id) { siz[id] = siz[ch[id][0]] + siz[ch[id][1]] + cnt[id]; }
void Rotate(int& id, int d) {
int temp = ch[id][d ^ 1];
ch[id][d ^ 1] = ch[temp][d];
ch[temp][d] = id;
id = temp;
PushUp(ch[id][d]);
PushUp(id);
}
void _Insert(int& id, TreapNode v, int num) {
if (!id)
id = NewNode(v, num);
else {
if (v == val[id])
cnt[id] += num;
else {
int d = val[id] > v ? 0 : 1;
_Insert(ch[id][d], v, num);
if (dat[id] < dat[ch[id][d]]) Rotate(id, d ^ 1);
}
PushUp(id);
}
}
void _Remove(int& id, TreapNode v, int num) {
if (!id)
return;
else {
if (v == val[id]) {
if (cnt[id] > num) {
cnt[id] -= num;
PushUp(id);
} else if (ch[id][0] || ch[id][1]) {
if (!ch[id][1] || dat[ch[id][0]] > dat[ch[id][1]])
Rotate(id, 1), _Remove(ch[id][1], v, num);
else
Rotate(id, 0), _Remove(ch[id][0], v, num);
PushUp(id);
} else
id = 0;
} else {
val[id] > v ? _Remove(ch[id][0], v, num) : _Remove(ch[id][1], v, num);
PushUp(id);
}
}
}
int _GetRank(int id, TreapNode v) {
int res = 1;
while (id) {
if (val[id] > v)
id = ch[id][0];
else if (val[id] == v) {
res += siz[ch[id][0]];
break;
} else {
res += siz[ch[id][0]] + cnt[id];
id = ch[id][1];
}
}
return res;
}
TreapNode _GetValue(int id, int rk) {
TreapNode res = TNINF;
while (id) {
if (siz[ch[id][0]] >= rk)
id = ch[id][0];
else if (siz[ch[id][0]] + cnt[id] >= rk) {
res = val[id];
break;
} else {
rk -= siz[ch[id][0]] + cnt[id];
id = ch[id][1];
}
}
return res;
}
int Size() { return siz[root]; }
void Insert(TreapNode v, int num = 1) { _Insert(root, v, num); }
void Remove(TreapNode v, int num = INF) { _Remove(root, v, num); }
int GetRank(TreapNode v) { return _GetRank(root, v); }
TreapNode GetValue(int rk) { return _GetValue(root, rk); }
} treap1, treap2;
int n;
int a[200005];
int p[200005];
long long ans[200005];
void test_case() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
p[a[i]] = i;
}
treap1.Init();
treap2.Init();
int Lmost = p[1], Rmost = p[1];
long long cnt1 = 0, cnt2 = 0;
TreapNode cur(p[1], 1);
treap1.Insert(cur);
treap2.Insert(cur);
TreapNode mid1, mid2;
mid1 = mid2 = cur;
ans[1] = 0;
for (int i = 2; i <= n; ++i) {
cur = TreapNode(p[i], i);
treap1.Insert(cur, 1);
mid1 = treap1.GetValue((i + 1) / 2);
mid2 = treap1.GetValue(i / 2 + 1);
if (p[i] < Lmost) {
for (int j = Lmost - 1; j >= p[i]; --j) treap2.Insert(TreapNode(j, a[j]));
Lmost = p[i];
} else if (p[i] > Rmost) {
for (int j = Rmost + 1; j <= p[i]; ++j) treap2.Insert(TreapNode(j, a[j]));
Rmost = p[i];
}
cnt1 += i - treap1.GetRank(cur);
if (p[i] >= mid2.val1) {
cnt2 -= treap2.Size() - treap2.GetRank(cur);
cnt2 += treap2.Size() - treap2.GetRank(mid1) - i / 2;
} else if (p[i] <= mid1.val1) {
cnt2 -= treap2.GetRank(cur);
cnt2 += treap2.GetRank(mid2) - i / 2;
}
ans[i] = cnt1 + cnt2;
}
for (int i = 1; i <= n; ++i) printf("%lld%c", ans[i], " \n"[i == n]);
}
int main() {
int t = 1;
for (int ti = 1; ti <= t; ++ti) {
test_case();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const bool debug = true;
int p[200001];
int pos[200001];
class seg_tree {
int* st;
int n;
public:
seg_tree(int a) {
st = new int[2 * a];
for (int i = 0; i < 2 * a; i++) st[i] = 0;
n = a;
}
void set(int x) {
x += n;
st[x] = 1;
x /= 2;
while (x) {
st[x] = st[2 * x] + st[2 * x + 1];
x /= 2;
}
}
int query(int l, int r) {
l += n;
r += n;
int ans = 0;
while (l < r) {
if (l & 1) {
ans += st[l++];
}
if (r & 1) {
ans += st[--r];
}
l >>= 1;
r >>= 1;
}
return ans;
}
};
class median {
priority_queue<int, vector<int>, greater<int>> higher;
priority_queue<int> lower;
long long int suml, sumr;
public:
median() {
suml = 0;
sumr = 0;
}
void insert(int n) {
if ((lower.empty() && higher.empty()) || n < lower.top()) {
lower.push(n);
suml += n;
if (lower.size() > higher.size() + 1) {
higher.push(lower.top());
sumr += lower.top();
suml -= lower.top();
lower.pop();
}
} else {
higher.push(n);
sumr += n;
if (higher.size() > lower.size()) {
lower.push(higher.top());
suml += higher.top();
sumr -= higher.top();
higher.pop();
}
}
}
int get_median() { return lower.top(); }
long long get_swaps() {
long long int n = lower.size();
long long int l = lower.top() * n - suml - ((n) * (n - 1)) / 2;
n = higher.size();
long long r = sumr - lower.top() * n - ((n) * (n + 1)) / 2;
return l + r;
}
};
int main() {
int n;
cin >> n;
for (int z = 1; z < n + 1; z++) {
cin >> p[z];
pos[p[z]] = z;
}
seg_tree cind(n + 1);
median med;
long long inv = 0;
for (int z = 1; z < n + 1; z++) {
inv += cind.query(pos[z], n + 1);
cind.set(pos[z]);
med.insert(pos[z]);
cout << inv + med.get_swaps() << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1, base = (1 << 19);
int n, p[N], inv_t[2 * base + 1], where[N], pref;
long long pos_t[2 * base + 1];
void add(int pos) {
pos += base;
while (pos) {
inv_t[pos]++;
pos /= 2;
}
}
int sum(int l, int r) {
l += base;
r += base;
int res = inv_t[l];
if (l != r) {
res += inv_t[r];
}
while (l / 2 != r / 2) {
if (l % 2 == 0) {
res += inv_t[l + 1];
}
if (r % 2 == 1) {
res += inv_t[r - 1];
}
l /= 2;
r /= 2;
}
return res;
}
int find_med(int id, int k) {
if (id >= base) {
return id - base;
}
if (inv_t[id * 2] + pref >= k) {
return find_med(id * 2, k);
}
pref += inv_t[id * 2];
return find_med(id * 2 + 1, k);
}
void ins(int pos, long long val) {
pos += base;
while (pos) {
pos_t[pos] += val;
pos /= 2;
}
}
long long pos_q(int l, int r) {
l += base;
r += base;
long long res = pos_t[l];
if (l != r) {
res += pos_t[r];
}
while (l / 2 != r / 2) {
if (l % 2 == 0) {
res += pos_t[l + 1];
}
if (r % 2 == 1) {
res += pos_t[r - 1];
}
l /= 2;
r /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> p[i];
where[p[i]] = i;
}
long long inv = 0;
for (int i = 1; i <= n; ++i) {
long long l = sum(0, where[i]);
long long r = sum(where[i], n - 1);
inv += r;
add(where[i]);
ins(where[i], where[i]);
int med = find_med(1, (i - 1) / 2 + 1);
pref = 0;
l = sum(0, med) - 1;
r = sum(med, n - 1) - 1;
long long cost = -pos_q(0, med) + pos_q(med, n - 1) +
(long long)med * (l - r) - r * (r + 1LL) / 2LL -
l * (l + 1LL) / 2LL;
cout << inv + cost << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2e5 + 10;
int bit[MAX_N], n, pos[MAX_N], x;
long long ans = 0;
int lowbit(int x) { return x & (-x); }
int sum(int x) {
int res = 0;
while (x < MAX_N) {
res += bit[x];
x += lowbit(x);
}
return res;
}
void update(int x) {
while (x) {
bit[x] += 1;
x -= lowbit(x);
}
}
int get(int d) {
int l = 1, r = n;
while (l <= r) {
int mid = (l + r) >> 1;
if (sum(mid) >= d) {
l = mid + 1;
} else {
r = mid - 1;
}
}
return r;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
pos[x] = i;
}
for (int i = 1; i <= n; i++) {
int mid = (i + 1) / 2;
if (i & 1) {
update(pos[i]);
int k = get(mid);
int dis = abs(pos[i] - k) - abs(sum(pos[i]) - sum(k));
if (pos[i] < k) {
ans += -(sum(1) - sum(pos[i]));
} else {
ans += -sum(pos[i] + 1);
}
ans += dis + sum(pos[i] + 1);
} else {
int k = get(mid);
int dis =
abs(pos[i] - k) - abs(sum(pos[i]) + (pos[i] < k ? 1 : 0) - sum(k));
if (pos[i] < k) {
ans += -(sum(1) - sum(pos[i]));
} else {
ans += -sum(pos[i] + 1);
}
ans += dis + sum(pos[i] + 1);
update(pos[i]);
}
printf("%I64d ", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 5;
int a[MAX], p[MAX], n;
long long c1[MAX], c2[MAX];
set<int> st;
void add(long long *c, int x, int k) {
for (; x <= n; x += x & -x) c[x] += k;
}
long long query(long long *c, int x) {
long long sum = 0;
for (; x; x -= x & -x) sum += c[x];
return sum;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), p[a[i]] = i;
st.insert(p[1]);
auto it = st.begin();
printf("0 ");
add(c1, p[1], 1);
add(c2, p[1], p[1]);
long long res = 0;
for (int i = 2; i <= n; i++) {
st.insert(p[i]);
if (p[i] < (*it) && i % 2 == 0) it--;
if (p[i] > (*it) && i % 2 == 1) it++;
add(c1, p[i], 1);
res += (i * 1ll - query(c1, p[i]));
add(c2, p[i], p[i]);
int midpos = *it;
long long sum = 0, k = i / 2;
sum += i & 1 ? k * (midpos - 1 + midpos - k) / 2
: (k - 1) * (midpos + midpos - k) / 2;
sum -= k * (midpos + 1 + midpos + k) / 2;
sum -= query(c2, midpos - 1);
sum += query(c2, n) - query(c2, midpos);
printf("%I64d ", res + sum);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1061109567;
const int MAXN = 201010;
int n, median;
int v[MAXN];
int ind[MAXN];
long long st[4 * MAXN];
long long adjust[MAXN];
long long inversions[MAXN];
priority_queue<int> maxheap;
priority_queue<int, vector<int>, greater<int> > minheap;
void update(int nd, int l, int r, int pos, int x) {
if (l == r) {
st[nd] = x;
return;
}
if (pos < l || pos > r) return;
int mid = (l + r) >> 1;
int nxt = nd << 1;
if (pos <= mid) update(nxt, l, mid, pos, x);
if (pos > mid) update(nxt + 1, mid + 1, r, pos, x);
st[nd] = st[nxt] + st[nxt + 1];
}
long long query(int nd, int l, int r, int lq, int rq) {
if (r < lq || rq < l) return 0;
if (lq <= l && r <= rq) return st[nd];
int mid = (l + r) >> 1;
int nxt = nd << 1;
return query(nxt, l, mid, lq, rq) + query(nxt + 1, mid + 1, r, lq, rq);
}
long long gather(int k, int med_pos) {
long long rh = k - (k / 2);
long long lh = k - rh;
long long r_tar_sum = ((med_pos + (med_pos + rh - 1)) * rh) / 2;
long long l_tar_sum = ((med_pos - 1 + (med_pos - lh)) * lh) / 2;
long long r_pos_sum = query(1, 0, n, med_pos, n);
long long l_pos_sum = query(1, 0, n, 0, max(0, med_pos - 1));
long long ret_val = (l_tar_sum - l_pos_sum) + (r_pos_sum - r_tar_sum);
return ret_val;
}
void reset_seg_tree() {
for (int i = 1; i <= n; i++) update(1, 0, n, i, 0);
return;
}
void heap_insert(int x) {
if (maxheap.size() > minheap.size()) {
if (x < median) {
minheap.push(maxheap.top());
maxheap.pop();
maxheap.push(x);
} else {
minheap.push(x);
}
median = minheap.top();
} else if (maxheap.size() == minheap.size()) {
if (x < median) {
maxheap.push(x);
median = maxheap.top();
} else {
minheap.push(x);
median = minheap.top();
}
} else {
if (x > median) {
maxheap.push(minheap.top());
minheap.pop();
minheap.push(x);
} else {
maxheap.push(x);
}
median = minheap.top();
}
return;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> v[i];
ind[v[i]] = i;
}
for (int k = 1; k <= n; k++) {
heap_insert(ind[k]);
update(1, 0, n, ind[k], ind[k]);
adjust[k] = gather(k, median);
}
reset_seg_tree();
inversions[0] = 0;
for (int k = 1; k <= n; k++) {
inversions[k] = inversions[k - 1] + query(1, 0, n, ind[k] + 1, n - 1);
update(1, 0, n, ind[k], 1);
}
for (int i = 1; i <= n; i++)
cout << (inversions[i] + adjust[i]) << " \n"[i == n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
long long bit[N] = {};
int idx[N] = {};
int n;
priority_queue<int> A;
priority_queue<int, vector<int>, greater<int>> B;
inline long long __abs(int x) { return (x ^ (x >> 31)) - (x >> 31); }
long long sum(int x) {
int ret = 0;
while (x) {
ret += bit[x];
x -= (x & -x);
}
return ret;
}
void add(int x, int val) {
while (x <= n) {
bit[x] += val;
x += (x & -x);
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
long long x, now = 0, d = 0, t, f, p;
for (int i = 1; i <= n; i++) {
cin >> x;
idx[x] = i;
}
x = idx[1];
for (long long i = 1; i <= n; i++) {
B.emplace(idx[i]);
A.emplace(B.top());
B.pop();
while (A.size() > ((i + 1) >> 1)) {
B.emplace(A.top());
A.pop();
}
while (A.size() < B.size()) {
A.emplace(B.top());
B.pop();
}
f = A.top(), p = (i / 2) * (i / 2 + 1) - (i / 2) * ((i & 1) == 0),
t = A.size() - (f > x);
now += __abs(idx[i] - x) + (f - x) * (t + t - i);
x = f;
add(idx[i], 1);
d += i - sum(idx[i]);
cout << now - p + d << " \n"[i == n];
}
return 0;
}
|
#include <bits/stdc++.h>
const int inf = (1 << 29) - 1;
const int maxn = (int)2e5 + 10;
const int mod = (int)1e9 + 7;
using namespace std;
int n;
int p[maxn];
long long t[2][maxn];
int rp[maxn];
void upd(int id, int pos, int val) {
for (int i = pos; i <= n; i |= i + 1) t[id][i] += val;
}
long long get(int id, int pos) {
long long res = 0;
while (pos >= 0) {
res += t[id][pos];
pos = (pos & (pos + 1)) - 1;
}
return res;
}
set<int> s1, s2;
long long inv;
long long add(int p, int k) {
inv += get(0, n) - get(0, p);
upd(0, p, 1);
upd(1, p, p);
long long ans = inv;
s2.insert(p);
s1.insert(*s2.begin());
s2.erase(s2.begin());
if (s2.size() + 2 <= s1.size()) {
s2.insert(*(--s1.end()));
s1.erase(--s1.end());
}
long long m = *(--s1.end());
long long F = s1.size() - 1;
long long S = s2.size();
ans += F * m - get(1, m - 1) - F * (F + 1ll) / 2;
ans += get(1, n) - get(1, m) - m * S - S * (S + 1ll) / 2;
return ans;
}
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i];
rp[p[i]] = i;
}
for (int i = 1; i <= n; i++) {
int pos = rp[i];
cout << add(pos, i) << "\n";
}
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
long long mid[N], a[N], mark[N], k, f1[N][2], n, g[N], h[N], p, ct, cn,
tvn = 1, tedad[N * 4];
string s, s2;
long long saghf(long long x) { return (x / 2) + (x % 2); }
string binary(int m, int k) {
string g = "";
for (long long i = 0; i < k; i++) {
g += char((m % 2) + '0');
m = m / 2;
}
return g;
}
int main() {
cin >> n;
cn = n;
for (long long i = 1; i < n + 1; i++)
cin >> a[i], mark[a[i]] = i, f1[i][0] = i - 1, f1[i][1] = i + 1;
k = saghf(n);
for (long long i = n; i >= 1; i--) {
mid[i] = k;
if (i % 2 == 0) {
if (mark[i] <= k) k = f1[k][1];
} else {
if (mark[i] >= k) k = f1[k][0];
}
f1[f1[mark[i]][0]][1] = f1[mark[i]][1];
f1[f1[mark[i]][1]][0] = f1[mark[i]][0];
}
k = 0;
for (long long i = 2; i < n; i++) {
if (i % 2 == 0) {
if (mid[i] == mid[i - 1])
g[i] = g[i - 1] + (mark[i] - mid[i]) - (i / 2);
else
g[i] =
g[i - 1] + (mid[i - 1] - mid[i]) + (mid[i] - mark[i]) - ((i / 2));
} else {
if (mid[i] == mid[i - 1])
g[i] = g[i - 1] + (mid[i] - mark[i]) - (i / 2);
else
g[i] = g[i - 1] + (mark[i] - mid[i]) - (i / 2);
}
}
for (long long i = 1; i < (n + 3) / 2; i++) {
swap(a[i], a[n + 1 - i]);
a[i] = n + 1 - a[i];
a[n + 1 - i] = n + 1 - a[n + 1 - i];
}
if (n % 2 == 1) a[(n + 1) / 2] = n + 1 - a[(n + 1) / 2];
while (cn) {
k++;
cn /= 2;
tvn *= 2;
}
tvn /= 2;
for (long long i = 1; i < n + 1; i++) {
s = binary(a[i], k);
p = 0;
ct = tvn;
long long t = 0, m = tvn * 2 - a[i], p1 = tvn * 2;
s2 = binary(m, k);
for (long long j = k - 1; j >= 0; j--) {
if (s2[j] == '1') {
p1 -= ct;
t += tedad[p1];
}
ct /= 2;
}
h[n + 1 - a[i]] = t;
ct = tvn;
for (long long j = k - 1; j >= 0; j--) {
if (s[j] == '1') {
p += ct;
tedad[p]++;
}
ct /= 2;
}
}
for (long long i = 1; i < n + 1; i++) {
h[i] += h[i - 1];
cout << h[i] + g[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
long long bit[N] = {};
int idx[N] = {};
int n;
priority_queue<int> A;
priority_queue<int, vector<int>, greater<int>> B;
long long sum(int x) {
int ret = 0;
while (x) {
ret += bit[x];
x -= (x & -x);
}
return ret;
}
void add(int x, int val) {
while (x <= n) {
bit[x] += val;
x += (x & -x);
}
}
int main() {
cin >> n;
long long x;
for (int i = 1; i <= n; i++) {
cin >> x;
idx[x] = i;
}
long long now = 0, d = 0, t;
x = idx[1];
for (int i = 1; i <= n; i++) {
B.emplace(idx[i]);
A.emplace(B.top());
B.pop();
while (A.size() > ((i + 1) >> 1)) {
B.emplace(A.top());
A.pop();
}
while (A.size() < B.size()) {
A.emplace(B.top());
B.pop();
}
long long f = A.top(),
p = (long long)(i / 2) * (i / 2 + 1) - (i / 2) * ((i & 1) == 0),
t = (long long)A.size() - (f >= x);
now += abs(idx[i] - x) + (f - x) * (t + t - i);
x = f;
add(idx[i], 1);
d += i - sum(idx[i]);
cout << now - p + d << " \n"[i == n];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n;
int pos[maxn];
long long sum1[maxn], sum2[maxn];
int lowbit(int x) { return x & -x; }
void add(long long *sum, int x, long long v) {
while (x <= n) {
sum[x] += v;
x += lowbit(x);
}
}
long long query(long long *sum, int x) {
long long ans = 0;
while (x > 0) {
ans += sum[x];
x -= lowbit(x);
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int p;
scanf("%d", &p);
pos[p] = i;
}
long long rev = 0;
for (int i = 1; i <= n; i++) {
add(sum1, pos[i], 1);
add(sum2, pos[i], pos[i]);
rev += i - query(sum1, pos[i]);
int l = 1, r = n, mid = (l + r) >> 1;
while (l < r) {
if (query(sum1, mid) <= i / 2)
l = mid + 1;
else
r = mid;
mid = (l + r) >> 1;
}
long long cntl = query(sum1, mid) - 1, cntr = i - cntl - 1;
long long ans = 1LL * mid * (cntl - cntr + 1) + query(sum2, n) -
2 * query(sum2, mid) - (cntl + 1) * cntl / 2 -
(cntr + 1) * cntr / 2;
ans += rev;
printf("%lld ", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ans, n, a[210000], x, sum1, sum2, las;
int rd[450000], siz[450000], son[450000][2], v[450000], root, num[450000], cnt;
priority_queue<int> q1;
priority_queue<int, vector<int>, greater<int> > q2;
inline void update(int x) {
if (!q2.size() || x > q2.top())
q2.push(x), sum2 += x;
else
q1.push(x), sum1 += x;
if (q1.size() > q2.size() + 1) {
sum1 -= q1.top(), sum2 += q1.top();
q2.push(q1.top());
q1.pop();
}
if (q2.size() > q1.size() + 1) {
sum2 -= q2.top(), sum1 += q2.top();
q1.push(q2.top());
q2.pop();
}
return;
}
inline int ask() {
if (q1.size() > q2.size()) return q1.top();
return q2.top();
}
int judge(int id) {
int ans = 1;
if (son[id][0]) ans++;
if (son[id][1]) ans += 2;
return ans;
}
void push_up(int id) {
siz[id] = siz[son[id][0]] + siz[son[id][1]] + num[id];
return;
}
void rotate(int &p, int d) {
int r = son[p][d ^ 1];
son[p][d ^ 1] = son[r][d];
son[r][d] = p;
push_up(p);
push_up(r);
p = r;
return;
}
void ins(int &p, int d) {
if (!p) {
p = ++cnt;
v[p] = d;
num[p] = siz[p] = 1;
rd[p] = rand();
return;
}
if (v[p] == d) {
num[p]++;
siz[p]++;
return;
}
int t = 0;
if (v[p] < d) t = 1;
ins(son[p][t], d);
if (rd[p] < rd[son[p][t]]) rotate(p, t ^ 1);
push_up(p);
return;
}
int rk(int p, int x) {
if (!p) return 0;
if (v[p] == x) return siz[son[p][0]] + 1;
if (v[p] < x) return siz[son[p][0]] + rk(son[p][1], x) + num[p];
if (v[p] > x) return rk(son[p][0], x);
}
int find(int p, int x) {
if (!p) return 0;
if (siz[son[p][0]] >= x) return find(son[p][0], x);
if (siz[son[p][0]] + num[p] >= x) return v[p];
return find(son[p][1], x - (siz[son[p][0]] + num[p]));
}
int main() {
srand((unsigned)time(NULL));
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
a[x] = i;
}
for (int i = 1; i <= n; i++) {
update(a[i]);
int x = ask();
if (q2.size() >= q1.size()) {
ans =
sum2 - (1ll * q2.size() * x) - 1ll * (q2.size() - 1) * q2.size() / 2;
ans +=
(1ll * q1.size() * x) - sum1 - 1ll * (q1.size() + 1) * q1.size() / 2;
} else {
ans =
sum2 - (1ll * q2.size() * x) - 1ll * (q2.size() + 1) * q2.size() / 2;
ans +=
(1ll * q1.size() * x) - sum1 - 1ll * (q1.size() - 1) * q1.size() / 2;
}
ins(root, a[i]);
long long rr = rk(root, a[i]);
las += i - rr;
ans += las;
printf("%lld ", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
const long long maxn = 200000 + 10;
class BIT {
private:
long long n;
long long bit[maxn];
public:
BIT(long long size) {
n = size;
std::fill(bit, bit + maxn, 0);
}
void add(long long x, long long v) {
while (x <= this->n) {
bit[x] += v;
x += ((x) & (-x));
}
}
long long query(long long x) {
long long ans = 0;
while (x) {
ans += bit[x];
x -= ((x) & (-x));
}
return ans;
}
long long find_k(long long k) {
long long bits = 0;
long long n = this->n;
while (n) {
n >>= 1;
bits++;
}
long long mask = 0;
long long cnt = 0;
for (long long i = bits; i >= 0; i--) {
mask += 1 << i;
if (mask > this->n || cnt + bit[mask] >= k)
mask -= (1 << i);
else
cnt += bit[mask];
}
return mask + 1;
}
};
long long n, pos[maxn];
struct TreeNode {
long long zeros, preadd, sufadd;
long long presum, sufsum;
};
TreeNode seg[1111111];
void build_tree(long long node, long long L, long long R) {
seg[node].zeros = R - L + 1;
if (L == R) return;
long long M = L + (R - L) / 2;
build_tree(node << 1, L, M);
build_tree(node << 1 | 1, M + 1, R);
}
void push_down(long long node, long long L, long long R) {
long long lch = node << 1;
long long rch = node << 1 | 1;
if (seg[node].preadd) {
seg[lch].preadd += seg[node].preadd;
seg[rch].preadd += seg[node].preadd;
seg[lch].presum += seg[lch].zeros * 1LL * seg[node].preadd;
seg[rch].presum += seg[rch].zeros * 1LL * seg[node].preadd;
seg[node].preadd = 0;
}
if (seg[node].sufadd) {
seg[lch].sufadd += seg[node].sufadd;
seg[rch].sufadd += seg[node].sufadd;
seg[lch].sufsum += seg[lch].zeros * 1LL * seg[node].sufadd;
seg[rch].sufsum += seg[rch].zeros * 1LL * seg[node].sufadd;
seg[node].sufadd = 0;
}
}
long long qL, qR;
void add(long long node, long long L, long long R, long long type) {
if (qL <= L && R <= qR) {
if (type == 0) {
seg[node].preadd += 1;
seg[node].presum += (long long)seg[node].zeros;
} else {
seg[node].sufadd += 1;
seg[node].sufsum += (long long)seg[node].zeros;
}
return;
}
push_down(node, L, R);
long long M = L + (R - L) / 2;
if (qL <= M) add(node << 1, L, M, type);
if (qR > M) add(node << 1 | 1, M + 1, R, type);
long long lch = node << 1;
long long rch = node << 1 | 1;
seg[node].zeros = seg[lch].zeros + seg[rch].zeros;
seg[node].presum = seg[lch].presum + seg[rch].presum;
seg[node].sufsum = seg[lch].sufsum + seg[rch].sufsum;
}
void erase(long long node, long long L, long long R, long long p) {
if (L == R) {
memset(seg + node, 0, sizeof(TreeNode));
return;
}
long long M = L + (R - L) / 2;
long long lch = node << 1;
long long rch = node << 1 | 1;
push_down(node, L, R);
if (p <= M)
erase(lch, L, M, p);
else
erase(rch, M + 1, R, p);
seg[node].zeros = seg[lch].zeros + seg[rch].zeros;
seg[node].presum = seg[lch].presum + seg[rch].presum;
seg[node].sufsum = seg[lch].sufsum + seg[rch].sufsum;
}
long long query(long long node, long long L, long long R, long long type) {
if (qL <= L && R <= qR) {
if (type == 0)
return seg[node].presum;
else
return seg[node].sufsum;
}
push_down(node, L, R);
long long ans = 0;
long long M = L + (R - L) / 2;
if (qL <= M) ans += query(node << 1, L, M, type);
if (qR > M) ans += query(node << 1 | 1, M + 1, R, type);
return ans;
}
int main() {
scanf("%lld", &n);
BIT bit(n);
for (long long i = 1; i <= n; i++) {
long long a;
scanf("%lld", &a);
pos[a] = i;
}
build_tree(1, 1, n);
long long inversion = 0;
for (long long i = 1; i <= n; i++) {
const long long &p = pos[i];
inversion += i - 1 - bit.query(p);
bit.add(p, 1);
qL = p + 1;
qR = n;
if (qL <= qR) add(1, 1, n, 0);
qL = 1;
qR = p - 1;
if (qL <= qR) add(1, 1, n, 1);
erase(1, 1, n, p);
long long sum = 0;
long long median = bit.find_k((i + 1) / 2);
qL = 1;
qR = median - 1;
if (qL <= qR) {
sum += query(1, 1, n, 0);
}
qL = median + 1;
qR = n;
if (qL <= qR) {
sum += query(1, 1, n, 1);
}
long long ans = inversion + sum;
printf("%lld ", ans);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 200000 + 10;
long long BIT1[MAXN], BIT2[MAXN];
long long N;
void update(long long p, long long num, long long *BIT) {
for (; p <= N; p += p & -p) {
BIT[p] += num;
}
}
long long query(long long p, long long *BIT) {
long long sum = 0;
for (; p > 0; p -= p & -p) {
sum += BIT[p];
}
return sum;
}
long long arr_num[MAXN], arr_pos[MAXN];
signed main(void) {
cin >> N;
for (long long i = 1; i <= N; i++) {
cin >> arr_num[i];
arr_pos[arr_num[i]] = i;
}
long long ans = 0;
for (long long i = 1; i <= N; i++) {
ans += i - query(arr_pos[i], BIT1) - 1;
update(arr_pos[i], 1, BIT1);
update(arr_pos[i], arr_pos[i], BIT2);
long long lb = 1, ub = N;
while (ub > lb) {
long long mid = (lb + ub + 1) >> 1;
if (query(mid - 1, BIT1) > i / 2) {
ub = mid - 1;
} else {
lb = mid;
}
}
long long upper = query(N, BIT1) - query(ub, BIT1);
long long add1 =
query(N, BIT2) - query(ub, BIT2) - ub * upper - (1 + upper) * upper / 2;
long long lower = query(ub - 1, BIT1);
long long add2 = ub * lower - query(ub - 1, BIT2) - (1 + lower) * lower / 2;
cout << ans + add1 + add2 << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
long long sum1[MAXN], sum2[MAXN], a[MAXN], pos[MAXN];
void add1(long long x, long long y) {
if (!x) return;
for (; x < MAXN; x += x & -x) {
sum1[x] += y;
}
}
long long query1(long long x) {
long long ans = 0;
for (; x; x -= x & -x) {
ans += sum1[x];
}
return ans;
}
void add2(long long x, long long y) {
if (!x) return;
for (; x < MAXN; x += x & -x) {
sum2[x] += y;
}
}
long long query2(long long x) {
long long ans = 0;
for (; x; x -= x & -x) {
ans += sum2[x];
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
while (cin >> n) {
memset(sum1, 0, sizeof(sum1));
memset(sum2, 0, sizeof(sum2));
long long ans = 0;
for (int i = 1; i <= n; i++) cin >> a[i], pos[a[i]] = i;
for (int i = 1; i <= n; i++) {
int p = pos[i];
add1(p, 1);
add2(p, p);
ans += i - query1(p);
long long pp = ans;
long long l = 1, r = n, temp;
while (l <= r) {
int mid = (l + r) >> 1;
if (query1(mid) * 2 > i) {
temp = mid;
r = mid - 1;
} else
l = mid + 1;
}
long long x = query1(temp);
pp += (temp - x + 1 + temp) * x / 2 - query2(temp);
x = i - x;
pp += query2(n) - query2(temp) - ((temp + 1 + temp + x) * x / 2);
cout << pp << " ";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double Pi = acos(-1);
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
double dpow(double a, long long b) {
double ans = 1.0;
while (b) {
if (b % 2) ans = ans * a;
a = a * a;
b /= 2;
}
return ans;
}
long long quick_pow(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) {
ans = ans * x % mod;
}
x = x * x % mod;
y >>= 1;
}
return ans;
}
int n;
int a[maxn], c[maxn];
int lowbit(int x) { return x & (-x); }
long long bit1[maxn], bit2[maxn];
void add(long long *bit, int pos, int val) {
while (pos < maxn) {
bit[pos] += val;
pos += lowbit(pos);
}
}
long long query(long long *bit, int pos) {
long long ans = 0;
while (pos) {
ans += bit[pos];
pos -= lowbit(pos);
}
return ans;
}
int bs(long long *bit, int val) {
int i = 0;
for (int j = 19; j >= 0; j--) {
if ((i | 1 << j) < maxn) {
if (bit[i | 1 << j] <= val) {
val -= bit[i |= 1 << j];
}
}
}
return i;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
c[a[i]] = i;
}
long long cnt = 0;
for (int i = 1; i <= n; i++) {
int p = c[i];
add(bit1, p, 1);
cnt += i - query(bit1, p);
add(bit2, p, p);
int pos = bs(bit1, i / 2) + 1;
long long sum = 0;
long long aa = i / 2, bb = i - i / 2 - 1;
sum += (long long)aa * pos - (long long)aa * (aa + 1) / 2 -
query(bit2, pos - 1);
sum += (query(bit2, maxn) - query(bit2, pos)) - (long long)bb * pos -
(long long)bb * (bb + 1) / 2;
printf("%lld\n", sum + cnt);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int s[200005], sum[200005], ara[200005], p[200005], seg[4 * 200005];
void add(int x, int n) {
while (x <= n) {
sum[x]++;
x += (x & -x);
}
return;
}
int query(int x) {
int ret = 0;
while (x) {
ret += sum[x];
x -= (x & -x);
}
return ret;
}
void update(int n, int s, int e, int indx) {
if (s == indx && e == indx) {
seg[n]++;
return;
}
if (s > indx || e < indx) return;
int mid = (s + e) / 2;
update(n * 2, s, mid, indx);
update(n * 2 + 1, mid + 1, e, indx);
seg[n] = seg[n * 2] + seg[n * 2 + 1];
return;
}
int query(int n, int s, int e, int k) {
if (s == e && k == 1) return s;
int mid = (s + e) / 2;
if (seg[n * 2] < k)
return query(n * 2 + 1, mid + 1, e, k - seg[n * 2]);
else
return query(n * 2, s, mid, k);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &ara[i]), p[ara[i]] = i;
for (int i = 1; i <= n; i++) s[i] = query(n) - query(p[i]), add(p[i], n);
printf("0");
long long res = 0;
memset(sum, 0, sizeof sum);
add(p[1], n);
update(1, 1, n, p[1]);
int mn = p[1], mx = p[1];
for (int i = 2; i <= n; i++) {
res += s[i];
update(1, 1, n, p[i]);
add(p[i], n);
if (p[i] < mn || p[i] > mx)
mn = min(mn, p[i]), mx = max(mx, p[i]);
else {
int x1 = query(p[i] - 1);
int x2 = query(n) - x1 - 1;
res -= min(x1, x2);
}
int l = p[i], r = query(1, 1, n, (i + 1) / 2);
if (!(i & 1) && p[i] <= r) r = query(1, 1, n, (i + 2) / 2);
if (l > r) swap(l, r);
if (l < r) res += (r - l + 1) - (query(r) - query(l - 1));
printf(" %lld", res);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
int n, sum[maxn], r[maxn];
void add(int i) {
while (i <= n) {
sum[i]++;
i += i & (-i);
}
}
int getsum(int i) {
int ans = 0;
while (i) {
ans += sum[i];
i -= i & (-i);
}
return ans;
}
int bs(int s, int e, int t) {
int mid = (s + e) / 2;
if (s >= e) return mid;
if (getsum(mid) >= t)
return bs(s, mid, t);
else
return bs(mid + 1, e, t);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
r[x] = i;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += i - 1 - getsum(r[i]);
int s, e;
s = bs(1, n, i / 2);
if (i % 2 == 1)
e = bs(1, n, i / 2 + 1);
else
e = s;
if (!(s <= r[i] && r[i] <= e)) {
if (r[i] < s)
ans += s - r[i] - 1 - getsum(s - 1);
else
ans += r[i] - e + getsum(e) - i;
} else
ans -= i / 2;
cout << ans << " ";
add(r[i]);
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using dd = double;
using pll = pair<ll, ll>;
using tll = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vdd = vector<dd>;
using vpll = vector<pll>;
using vtll = vector<tll>;
using vvll = vector<vll>;
using vvdd = vector<vdd>;
using vvpll = vector<vpll>;
using vvtll = vector<vtll>;
using vvvll = vector<vvll>;
using vvvdd = vector<vvdd>;
using vvvpll = vector<vvpll>;
using vvvtll = vector<vvtll>;
using vvvvll = vector<vvvll>;
using vvvvdd = vector<vvvdd>;
using vvvvpll = vector<vvvpll>;
using vvvvtll = vector<vvvtll>;
constexpr ll INF = 1LL << 60;
constexpr dd EPS = 1e-11;
struct Fast {
Fast() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(std::numeric_limits<double>::max_digits10);
}
} fast;
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline T MaxE(vector<T> &v, ll S, ll E) {
T m = v[S];
for (ll i = (S); i <= (E); i++) chmax(m, v[i]);
return m;
}
template <class T>
inline T MinE(vector<T> &v, ll S, ll E) {
T m = v[S];
for (ll i = (S); i <= (E); i++) chmin(m, v[i]);
return m;
}
template <class T>
inline T MaxE(vector<T> &v, ll N) {
return MaxE(v, 0, N - 1);
}
template <class T>
inline T MinE(vector<T> &v, ll N) {
return MinE(v, 0, N - 1);
}
template <class T>
inline T MaxE(vector<T> &v) {
return MaxE(v, (ll)v.size());
}
template <class T>
inline T MinE(vector<T> &v) {
return MinE(v, (ll)v.size());
}
template <class T>
inline ll MaxI(vector<T> &v, ll S, ll E) {
ll m = S;
for (ll i = (S); i <= (E); i++) {
if (v[i] > v[m]) m = i;
}
return m;
}
template <class T>
inline ll MinI(vector<T> &v, ll S, ll E) {
ll m = S;
for (ll i = (S); i <= (E); i++) {
if (v[i] < v[m]) m = i;
}
return m;
}
template <class T>
inline ll MaxI(vector<T> &v, ll N) {
return MaxI(v, 0, N - 1);
}
template <class T>
inline ll MinI(vector<T> &v, ll N) {
return MinI(v, 0, N - 1);
}
template <class T>
inline ll MaxI(vector<T> &v) {
return MaxI(v, (ll)v.size());
}
template <class T>
inline ll MinI(vector<T> &v) {
return MinI(v, (ll)v.size());
}
template <class T>
inline T Sum(vector<T> &v, ll S, ll E) {
T s = v[S];
for (ll i = (S + 1); i <= (E); i++) s += v[i];
return s;
}
template <class T>
inline T Sum(vector<T> &v, ll N) {
return Sum(v, 0, N - 1);
}
template <class T>
inline T Sum(vector<T> &v) {
return Sum(v, v.size());
}
template <class T>
inline ll Size(T &v) {
return (ll)v.size();
}
template <class T>
inline T POW(T a, ll n) {
T r = 1;
for (; n > 0; n >>= 1, a *= a) {
if (n & 1) r *= a;
}
return r;
}
inline ll POW(int a, ll n) { return POW((ll)a, n); }
inline ll MSB(ll a) {
for (ll o = 63, x = -1;;) {
ll m = (o + x) / 2;
if (a < (1LL << m))
o = m;
else
x = m;
if (o - x == 1) return x;
}
}
inline ll CEIL(ll a, ll b) { return (a + b - 1) / b; }
ll Gcd(ll a, ll b) { return (b == 0) ? a : Gcd(b, a % b); }
ll Lcm(ll a, ll b) { return a * b / Gcd(a, b); }
inline vll Bit2Idx(ll m) {
vll v;
for (ll i = 0; m; m >>= 1, i++)
if (m & 1) v.push_back(i);
return move(v);
}
inline ll BitNum(ll m) {
for (ll c = 0;; m >>= 1) {
c += m & 1;
if (!m) return c;
}
}
inline ll Bit(ll s, ll i) { return (s >> i) & 1; }
inline ll BitOn(ll s, ll i) { return s | (1LL << i); }
inline ll BitOff(ll s, ll i) { return s & ~(1LL << i); }
template <class T>
inline ll UnderNumOf(vector<T> &v, T x) {
return upper_bound(v.begin(), v.end(), x) - v.begin();
}
template <class T, class Pr>
inline ll UnderNumOf(vector<T> &v, T x, Pr pred) {
return upper_bound(v.begin(), v.end(), x, pred) - v.begin();
}
template <class T>
inline ll OverNumOf(vector<T> &v, T x) {
return (ll)v.size() - (lower_bound(v.begin(), v.end(), x) - v.begin());
}
template <class T, class Pr>
inline ll OverNumOf(vector<T> &v, T x, Pr pred) {
return (ll)v.size() - (lower_bound(v.begin(), v.end(), x, pred) - v.begin());
}
template <class T = ll>
inline vector<T> cinv(ll N) {
vector<T> v(N);
for (ll i = (0); i <= ((N)-1); i++) cin >> v[i];
return move(v);
}
template <class T = ll, class S = ll>
inline vector<pair<T, S>> cinv2(ll N) {
vector<pair<T, S>> v(N);
for (ll i = (0); i <= ((N)-1); i++) {
cin >> v[i].first >> v[i].second;
}
return move(v);
}
template <class T = ll, class S = ll, class R = ll>
inline vector<tuple<T, S, R>> cinv3(ll N) {
vector<tuple<T, S, R>> v(N);
for (ll i = (0); i <= ((N)-1); i++) {
cin >> get<0>(v[i]) >> get<1>(v[i]) >> get<2>(v[i]);
}
return move(v);
}
template <class T = ll, class S = ll, class R = ll, class Q = ll>
inline vector<tuple<T, S, R, Q>> cinv4(ll N) {
vector<tuple<T, S, R, Q>> v(N);
for (ll i = (0); i <= ((N)-1); i++) {
cin >> get<0>(v[i]) >> get<1>(v[i]) >> get<2>(v[i]) >> get<3>(v[i]);
}
return move(v);
}
template <class T = ll>
inline vector<vector<T>> cinvv(ll N, ll M) {
vector<vector<T>> vv(N);
for (ll i = (0); i <= ((N)-1); i++) vv[i] = cinv(M);
return move(vv);
}
template <class T>
inline void coutv(vector<T> &v, char deli = ' ') {
ll N = (ll)v.size();
for (ll i = (0); i <= ((N)-1); i++) {
cout << v[i] << ((i == N - 1) ? '\n' : deli);
}
}
template <class T>
void bye(T a) {
cout << a << '\n';
exit(0);
}
template <class T>
void Dump(vector<T> &v) {}
template <class T>
void Dump(vector<vector<T>> &v) {}
template <class T>
void Dump(vector<vector<vector<T>>> &v) {}
template <class T>
void Dump(vector<vector<vector<vector<T>>>> &v) {}
template <class T>
void Dump(vector<vector<vector<vector<vector<T>>>>> &v) {}
template <ll MOD>
struct mll_ {
ll val;
mll_(ll v = 0) : val(v % MOD) {
if (val < 0) val += MOD;
}
mll_ operator-() const { return -val; }
mll_ operator+(const mll_ &b) const { return val + b.val; }
mll_ operator-(const mll_ &b) const { return val - b.val; }
mll_ operator*(const mll_ &b) const { return val * b.val; }
mll_ operator/(const mll_ &b) const { return mll_(*this) /= b; }
mll_ operator+(ll b) const { return *this + mll_(b); }
mll_ operator-(ll b) const { return *this - mll_(b); }
mll_ operator*(ll b) const { return *this * mll_(b); }
friend mll_ operator+(ll a, const mll_ &b) { return b + a; }
friend mll_ operator-(ll a, const mll_ &b) { return -b + a; }
friend mll_ operator*(ll a, const mll_ &b) { return b * a; }
friend mll_ operator/(ll a, const mll_ &b) { return mll_(a) / b; }
mll_ &operator+=(const mll_ &b) {
val = (val + b.val) % MOD;
return *this;
}
mll_ &operator-=(const mll_ &b) {
val = (val + MOD - b.val) % MOD;
return *this;
}
mll_ &operator*=(const mll_ &b) {
val = (val * b.val) % MOD;
return *this;
}
mll_ &operator/=(const mll_ &b) {
ll c = b.val, d = MOD, u = 1, v = 0;
while (d) {
ll t = c / d;
c -= t * d;
swap(c, d);
u -= t * v;
swap(u, v);
}
val = val * u % MOD;
if (val < 0) val += MOD;
return *this;
}
mll_ &operator+=(ll b) { return *this += mll_(b); }
mll_ &operator-=(ll b) { return *this -= mll_(b); }
mll_ &operator*=(ll b) { return *this *= mll_(b); }
mll_ &operator/=(ll b) { return *this /= mll_(b); }
bool operator==(const mll_ &b) { return val == b.val; }
bool operator!=(const mll_ &b) { return val != b.val; }
bool operator==(ll b) { return *this == mll_(b); }
bool operator!=(ll b) { return *this != mll_(b); }
friend bool operator==(ll a, const mll_ &b) { return mll_(a) == b.val; }
friend bool operator!=(ll a, const mll_ &b) { return mll_(a) != b.val; }
friend ostream &operator<<(ostream &os, const mll_ &a) { return os << a.val; }
friend istream &operator>>(istream &is, mll_ &a) { return is >> a.val; }
static mll_ Combination(ll a, ll b) {
chmin(b, a - b);
if (b < 0) return mll_(0);
mll_ c = 1;
for (ll i = (0); i <= ((b)-1); i++) c *= a - i;
for (ll i = (0); i <= ((b)-1); i++) c /= i + 1;
return c;
}
};
using mll = mll_<1000000007LL>;
using vmll = std::vector<mll>;
using vvmll = std::vector<vmll>;
using vvvmll = std::vector<vvmll>;
using vvvvmll = std::vector<vvvmll>;
using vvvvvmll = std::vector<vvvvmll>;
template <class T>
struct SegmentTree {
using F = function<T(T, T)>;
vector<T> dat;
ll n;
F f;
T ti;
SegmentTree() {}
SegmentTree(vector<T> &v, F f, T ti) { Init(v, f, ti); }
void Init(vector<T> &v, F f, T ti) {
this->f = f;
this->ti = ti;
for (n = 1; n < (ll)v.size(); n *= 2)
;
dat.resize(2 * n - 1, ti);
for (ll i = (0); i <= (((ll)v.size()) - 1); i++) {
dat[i + n - 1] = v[i];
}
for (ll i = ((n - 1) - 1); i >= (0); i--) {
dat[i] = f(dat[2 * i + 1], dat[2 * i + 2]);
}
}
void Set(ll i, T x) {
i += n - 1;
dat[i] = x;
while (i > 0) {
i = (i - 1) / 2;
dat[i] = f(dat[2 * i + 1], dat[2 * i + 2]);
}
}
T Range(ll a, ll b) { return range(a, b, 0, 0, n); }
T operator[](ll i) { return dat[i + n - 1]; }
void Dump(ll w = 5) {
for (ll i = (0); i <= ((n)-1); i++)
for (ll k = i + n - 1, m = 1, p = 1; k >= 0;
p = m, m *= k % 2, k = (k == 0) ? -1 : (k - 1) / 2) {
if (m)
cerr << ((k < n - 1) ? " ┬ " : "") << setw(w) << dat[k];
else
cerr << ((p & ~m) ? " ┘ " : "");
if (k == 0) cerr << '\n';
}
cerr << '\n';
}
T range(ll a, ll b, ll k, ll l, ll r) {
if (r <= a || b <= l) return ti;
if (a <= l && r <= b) return dat[k];
return f(range(a, b, k * 2 + 1, l, (l + r) / 2),
range(a, b, k * 2 + 2, (l + r) / 2, r));
}
};
void solve() {
ll n;
cin >> n;
vector<ll> P = cinv<ll>(n);
vll loc(n + 1);
for (ll i = (0); i <= (n - 1); i++) {
loc[P[i]] = i;
}
vll ans;
ans.push_back(0);
set<ll> buf;
buf.insert(loc[1]);
ll x = 0;
ll y = 0;
auto it = buf.begin();
vll ini(n, 0);
ini[loc[1]] = 1;
SegmentTree<ll> sgt(
ini, [](ll x, ll y) { return x + y; }, 0);
ll T = 0;
ll S = 0;
for (ll k = (1); k <= (n - 1); k++) {
ll p = loc[k + 1];
if (k % 2 == 0) {
auto iit = it;
iit++;
if (p < *it) {
ll inter = *it - p - 1;
inter -= sgt.Range(p + 1, (*it));
T += inter;
T -= sgt.Range(0, p);
} else if (*iit < p) {
ll inter = p - *iit - 1;
inter -= sgt.Range((*iit) + 1, p);
T += inter;
T -= sgt.Range(p + 1, n);
} else {
T -= sgt.Range(p + 1, n);
}
} else {
if (p < *it) {
ll inter = *it - p - 1;
inter -= sgt.Range(p + 1, (*it));
T += inter;
T -= sgt.Range(0, p);
} else {
ll inter = p - *it - 1;
inter -= sgt.Range((*it) + 1, p);
T += inter;
T -= sgt.Range(p + 1, n);
}
}
S += sgt.Range(p + 1, n);
ans.push_back(T + S);
if (p < *it)
x++;
else
y++;
buf.insert(p);
if (x - 1 == y) {
it--;
x--;
y++;
} else if (x + 2 == y) {
it++;
x++;
y--;
}
sgt.Set(p, 1);
}
coutv(ans);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 2e5 + 5, MXX = 23;
const long long mod = 1e9 + 7, inf = 1e18 + 6;
int n, a[MX], ind[MX], ver[MX];
void add(int l) {
for (int i = l + 1; i < MX; i += i & -i) ver[i]++;
}
int ask(int pn) {
int ans = 0;
for (pn++; pn; pn -= pn & -pn) ans += ver[pn];
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(9);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) ind[a[i]] = i;
set<int> nw;
long long ans = 0;
int md = ind[1];
for (int i = 1; i < n + 1; ++i) {
nw.insert(ind[i]);
auto v = nw.find(ind[i]);
add(ind[i]);
int ver = ask(ind[i]);
if (i & 1) {
if (ind[i] > md) md = *next(nw.find(md), 1);
} else {
if (ind[i] < md) md = *prev(nw.find(md), 1);
}
if (md != ind[i]) {
int ls = ((i % 2 == 0) && md > ind[i] ? *next(nw.find(md), 1) : md);
int dis = ls - ind[i];
dis = max(dis, -dis);
dis--;
int fr = ((i % 2 == 0) && md > ind[i] ? (i / 2) : ((i - 1) / 2));
fr++;
int bs = ver - fr;
bs = max(bs, -bs);
bs--;
ans += (long long)(dis - bs);
}
if (md == ind[i] && (i % 2 == 0)) {
ans += *next(nw.find(md), 1) - md - 1;
}
ans -= (min(i - ver, ver - 1));
ans += i - ver;
cout << ans << ' ';
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
int size = 256 * 1024;
int Count(std::vector<int>& tree, int l, int r) {
l += size;
r += size;
int ans = 0;
while (l <= r) {
if (l % 2) {
ans += tree[l];
++l;
}
if (r % 2 == 0) {
ans += tree[r];
--r;
}
if (l > r) break;
r >>= 1;
l >>= 1;
}
return ans;
}
void Add(std::vector<int>& tree, int ind) {
ind += size;
while (ind) {
++tree[ind];
ind >>= 1;
}
}
int main() {
int64_t own = 0;
int n;
std::cin >> n;
std::vector<int> array(n);
std::vector<int> where(n);
std::vector<int> add(n);
for (int i = 0; i < n; ++i) {
std::cin >> array[i];
--array[i];
where[array[i]] = i;
}
{
std::vector<int> tree(size * 2, 0);
for (int i = 0; i < n; ++i) {
add[i] = Count(tree, where[i], n - 1);
Add(tree, where[i]);
}
}
std::cout << 0 << ' ';
std::set<int> pos;
pos.insert(where[0]);
int median = where[0];
int64_t dist = 0;
std::vector<int> tree(size * 2, 0);
Add(tree, where[0]);
for (int i = 1; i < n; ++i) {
own += add[i];
if (where[i] >= median) {
dist -= Count(tree, where[i], n - 1);
} else {
dist -= Count(tree, 0, where[i]);
}
pos.insert(where[i]);
if (where[i] > median && (i % 2 == 0)) {
median = *pos.upper_bound(median);
} else if (where[i] < median && (i % 2 == 1)) {
int n_median = *(--pos.lower_bound(median));
dist += (median - n_median - 1);
median = n_median;
}
if (where[i] > median) {
dist += (where[i] - median - Count(tree, median, where[i] - 1));
} else {
dist += (median - where[i] - Count(tree, where[i] + 1, median));
}
std::cout << own + dist << ' ';
Add(tree, where[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 200010;
long long tr1[N], tr2[N];
long long n;
long long c[N];
long long lowbit(long long x) { return x & -x; }
void ud(long long tr[], long long x, long long d) {
for (long long i = x; i <= n; i += lowbit(i)) {
tr[i] += d;
}
}
long long qur(long long tr[], long long x) {
long long ans = 0;
for (long long i = x; i; i -= lowbit(i)) {
ans += tr[i];
}
return ans;
}
long long get_pos(long long tr[], long long x) {
long long l = 0, r = n;
while (l < r) {
long long mid = (l + r) >> 1;
if (qur(tr, mid) >= x)
r = mid;
else
l = mid + 1;
}
return l;
}
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
c[x] = i;
}
long long d = 0;
for (long long i = 1; i <= n; i++) {
ud(tr1, c[i], 1);
ud(tr2, c[i], c[i]);
d += (i - qur(tr1, c[i]));
long long pos = get_pos(tr1, (i + 1) / 2);
long long aa = (i - 1) / 2;
long long bb = i / 2;
long long t1 = (long long)aa * pos - (1 + aa) * aa / 2;
long long t2 = (1ll + bb) * bb / 2 + bb * pos;
long long q1 = qur(tr2, pos - 1);
long long q2 = qur(tr2, n) - qur(tr2, pos);
long long ans = q2 - t2 + t1 - q1;
cout << (ans + d) << ' ';
}
}
|
#include <bits/stdc++.h>
const int maxn = 2e5 + 10;
const int maxm = 1e5 + 10;
const long long int mod = 1e9 + 7;
const long long int INF = 1e18 + 100;
const int inf = 0x3f3f3f3f;
const double pi = acos(-1.0);
const double eps = 1e-8;
using namespace std;
int n, m;
int cas, tol, T;
set<int> st;
int a[maxn], p[maxn];
long long int sum[maxn];
void update(int x) {
for (int i = x; i; i -= i & (-i)) sum[i]++;
}
long long int query(int x) {
if (x == 0) return 0;
int ans = 0;
for (int i = x; i <= n; i += i & (-i)) ans += sum[i];
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), p[a[i]] = i;
long long int ans = 0, k = 0;
printf("0 ");
update(p[1]);
st.insert(p[1]);
auto it = st.begin();
for (int i = 2; i <= n; i++) {
ans -= min(query(p[i] + 1), i - 1 - query(p[i] + 1));
ans += query(p[i] + 1);
update(p[i]), st.insert(p[i]);
if (i % 2 == 0 && p[i] < (*it)) ans += abs((*it) - (*(--it))) - 1;
if (i % 2 == 1 && p[i] > (*it)) it++;
if (p[i] > (*it))
ans += p[i] - (*it) + 1 - query((*it)) + query(p[i] + 1);
else
ans += (*it) - p[i] + 1 - query(p[i]) + query((*it) + 1);
printf("%lld ", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double Pi = acos(-1);
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
double dpow(double a, long long b) {
double ans = 1.0;
while (b) {
if (b % 2) ans = ans * a;
a = a * a;
b /= 2;
}
return ans;
}
long long quick_pow(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) {
ans = ans * x % mod;
}
x = x * x % mod;
y >>= 1;
}
return ans;
}
int n;
int a[maxn], c[maxn];
int lowbit(int x) { return x & (-x); }
long long bit1[maxn], bit2[maxn];
void add(long long *bit, int pos, int val) {
while (pos < maxn) {
bit[pos] += val;
pos += lowbit(pos);
}
}
long long query(long long *bit, int pos) {
long long ans = 0;
while (pos) {
ans += bit[pos];
pos -= lowbit(pos);
}
return ans;
}
int bs(long long *bit, int val) {
int i = 0;
for (int j = 19; j >= 0; j--) {
if ((i | 1 << j) < maxn) {
if (bit[i | 1 << j] <= val) {
val -= bit[i |= 1 << j];
}
}
}
return i;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
c[a[i]] = i;
}
long long cnt = 0;
for (int i = 1; i <= n; i++) {
int p = c[i];
add(bit1, p, 1);
cnt += i - query(bit1, p);
add(bit2, p, p);
int pos = bs(bit1, i / 2) + 1;
long long sum = 0;
long long aa = i / 2;
long long bb = i - i / 2 - 1;
sum += (long long)aa * pos - (long long)aa * (aa + 1) / 2 -
query(bit2, pos - 1);
sum += (query(bit2, maxn) - query(bit2, pos)) - (long long)bb * pos -
(long long)bb * (bb + 1) / 2;
printf("%lld\n", sum + cnt);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int n, k;
char s[maxn];
int pre[maxn << 1], sz[maxn << 1];
vector<int> op[maxn];
int find(int x) { return x == pre[x] ? x : pre[x] = find(pre[x]); }
void merge(int x, int y) {
int fx = find(x), fy = find(y);
if (fy == 0) swap(fx, fy);
if (fx != fy) pre[fy] = fx, sz[fx] += sz[fy];
}
int cal(int x) {
int y = (x <= k) ? x + k : x - k;
int fx = find(x), fy = find(y);
if (fx == 0 || fy == 0) return sz[fx + fy];
return min(sz[fx], sz[fy]);
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
for (int i = 1; i <= k; i++) pre[i] = i, pre[i + k] = i + k, sz[i + k] = 1;
for (int i = 1, c, x; i <= k; i++) {
scanf("%d", &c);
while (c--) {
scanf("%d", &x);
op[x].push_back(i);
}
}
int res = 0;
for (int i = 1; i <= n; i++) {
if (op[i].size() == 1) {
int x = op[i][0];
res -= cal(x);
if (s[i] == '1')
pre[find(x + k)] = 0;
else
pre[find(x)] = 0;
res += cal(x);
} else if (op[i].size() == 2) {
int x = op[i][0], y = op[i][1];
if (s[i] == '1') {
if (find(x) != find(y)) {
res -= cal(x) + cal(y);
merge(x, y), merge(x + k, y + k);
res += cal(x);
}
} else {
if (find(x + k) != find(y)) {
res -= cal(x) + cal(y);
merge(x + k, y), merge(x, y + k);
res += cal(x);
}
}
}
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
const int INF = 1e7;
char s[maxn];
int fa[maxn], siz[maxn];
int l[maxn][2];
int n, k;
int findset(int x) {
if (fa[x] == x) return x;
return fa[x] = findset(fa[x]);
}
void Union(int x, int y) {
int rx = findset(x), ry = findset(y);
if (!ry) swap(rx, ry);
if (rx) siz[rx] += siz[ry];
fa[ry] = rx;
}
int cal(int x) {
int y = x + k;
x = findset(x), y = findset(y);
return min(siz[x], siz[y]);
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
for (int i = 1; i <= k; i++) {
int m;
scanf("%d", &m);
for (int j = 1; j <= m; j++) {
int x;
scanf("%d", &x);
if (l[x][0] == 0)
l[x][0] = i;
else
l[x][1] = i;
}
siz[i] = 1;
fa[i] = i;
fa[i + k] = i + k;
}
siz[0] = INF;
int ans = 0;
for (int i = 1; i <= n; i++) {
int x = l[i][0], y = l[i][1];
int rx = findset(x), ry = findset(y);
int rxk = findset(x + k), ryk = findset(y + k);
if (!y) {
ans -= cal(x);
if (s[i] == '1') fa[rx] = 0;
if (s[i] == '0') fa[rxk] = 0;
ans += cal(x);
} else if (s[i] == '0' && rx != ryk) {
ans -= cal(x);
ans -= cal(y);
Union(x, y + k);
Union(y, x + k);
ans += cal(x);
} else if (s[i] == '1' && rx != ry) {
ans -= cal(x);
ans -= cal(y);
Union(x, y);
Union(x + k, y + k);
ans += cal(x);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 10, inf = 0x3f3f3f3f;
vector<int> v[maxn];
int fa[maxn];
long long cnt[maxn];
int n, k;
string s;
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void merge(int u, int v) {
u = find(u), v = find(v);
if (u == v) return;
cnt[u] += cnt[v];
fa[v] = u;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> s;
for (int i = 1, c, t; i <= k; i++) {
cin >> c;
while (c--) {
cin >> t;
v[t].push_back(i);
}
}
for (int i = 1; i <= k; i++) {
fa[i] = i, fa[i + k] = i + k;
cnt[i + k] = 1;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (v[i].size() == 0) {
printf("%d\n", ans);
continue;
} else if (v[i].size() == 1) {
int x = v[i][0];
ans -= min(cnt[find(x)], cnt[find(x + k)]);
if (s[i - 1] == '0')
cnt[find(x)] = inf;
else
cnt[find(x + k)] = inf;
ans += min(cnt[find(x)], cnt[find(x + k)]);
printf("%d\n", ans);
} else {
int x1 = v[i][0], x2 = v[i][1];
if (find(x1) == find(x2) || find(x1) == find(x2 + k)) {
printf("%d\n", ans);
continue;
}
ans -= min(cnt[find(x1)], cnt[find(x1 + k)]);
ans -= min(cnt[find(x2)], cnt[find(x2 + k)]);
if (s[i - 1] == '0') {
merge(x1, x2 + k);
merge(x1 + k, x2);
} else {
merge(x1, x2);
merge(x1 + k, x2 + k);
}
ans += min(cnt[find(x1)], cnt[find(x1 + k)]);
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxm = 3e5 + 5;
int fa[maxm << 1], cnt[maxm << 1], n, k, state[maxm][2];
int Find(int x) { return fa[x] == x ? x : fa[x] = Find(fa[x]); }
void Union(int x, int y) {
x = Find(x), y = Find(y);
if (y == 0) swap(x, y);
fa[y] = x;
if (x) cnt[x] += cnt[y];
}
int calc(int x) {
int y = x <= k ? x + k : x - k;
x = Find(x), y = Find(y);
if (x == 0 || y == 0) return cnt[x + y];
return min(cnt[x], cnt[y]);
}
void run_case() {
cin >> n >> k;
string str;
cin >> str;
for (int i = 1; i <= k; ++i) {
int num, lamp;
cin >> num;
while (num--) {
cin >> lamp;
if (!state[lamp][0])
state[lamp][0] = i;
else
state[lamp][1] = i;
}
fa[i] = i, fa[i + k] = i + k, cnt[i + k] = 1;
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (!state[i][1]) {
int x = state[i][0];
if (x) {
ans -= calc(x);
if (str[i - 1] == '0') {
fa[Find(x)] = 0;
} else
fa[Find(x + k)] = 0;
ans += calc(x);
}
} else {
int x = state[i][0], y = state[i][1];
if (str[i - 1] == '0') {
if (Find(x + k) != Find(y)) {
ans -= calc(x), ans -= calc(y);
Union(x, y + k), Union(x + k, y);
ans += calc(x);
}
} else {
if (Find(x) != Find(y)) {
ans -= calc(x), ans -= calc(y);
Union(x, y), Union(x + k, y + k);
ans += calc(x);
}
}
}
cout << ans << "\n";
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
run_case();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e6 + 100;
const int mod = (int)1e9 + 7;
int n, k, fa[maxn], tot[maxn], ans;
char s[maxn];
vector<int> v[maxn];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
void join(int x, int y) {
x = find(x);
y = find(y);
if (x != y) fa[x] = y, tot[y] += tot[x];
}
int get(int x) { return min(tot[find(x)], tot[find(x + k)]); }
int main() {
scanf("%d%d%s", &n, &k, s + 1);
for (int i = (1); i <= (k); ++i) {
int x, c;
scanf("%d", &c);
while (c--) scanf("%d", &x), v[x].push_back(i);
}
for (int i = (1); i <= (2 * k + 1); ++i) fa[i] = i, tot[i] = (i <= k);
tot[2 * k + 1] = mod;
for (int i = (1); i <= (n); ++i) {
if (v[i].size() == 1) {
int tmp = v[i][0] + (s[i] == '0') * k;
ans -= get(v[i][0]);
join(tmp, 2 * k + 1);
ans += get(v[i][0]);
}
if (v[i].size() == 2) {
int x = v[i][0], y = v[i][1];
if (s[i] == '1' && find(x) != find(y)) {
ans -= (get(x) + get(y));
join(x, y);
join(x + k, y + k);
ans += get(x);
}
if (s[i] == '0' && find(x) != find(y + k)) {
ans -= (get(x) + get(y));
join(x, y + k);
join(x + k, y);
ans += get(x);
}
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
int a[300005];
std::vector<int> g[300005];
int vis[600005], count[600005];
int p[600005];
int find(int u) {
if (p[u] == u)
return u;
else
return p[u] = find(p[u]);
}
void merge(int u, int v) {
int x = find(u), y = find(v);
if (x != y) {
if (x > y) {
p[y] = x;
count[x] += count[y];
count[y] = 0;
} else {
p[x] = y;
count[y] += count[x];
count[x] = 0;
}
}
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%1d", &a[i]);
for (int i = 1; i <= k; i++) {
int c;
scanf("%d", &c);
while (c--) {
int p;
scanf("%d", &p);
g[p].push_back(i);
}
p[i] = i;
p[i + k] = i + k;
count[i] = 0, count[i + k] = 1;
}
int ans = 0;
int True = 2 * k + 1;
p[True] = True;
count[True] = 0;
for (int i = 1; i <= n; i++) {
if ((int)g[i].size() != 0) {
if (g[i].size() == 1) {
int u = g[i][0];
int x = find(u), y = find(u + k);
if (x != True && y != True) {
if (vis[x]) vis[x] = 0, ans -= count[x];
if (vis[y]) vis[y] = 0, ans -= count[y];
ans -= count[True];
if (a[i] != 0)
merge(x, True);
else
merge(y, True);
vis[True] = 1;
ans += count[True];
}
} else {
int u = g[i][0], v = g[i][1];
int x0 = find(u), y0 = find(u + k), x1 = find(v), y1 = find(v + k);
if (vis[x0]) vis[x0] = 0, ans -= count[x0];
if (vis[y0]) vis[y0] = 0, ans -= count[y0];
if (vis[x1]) vis[x1] = 0, ans -= count[x1];
if (vis[y1]) vis[y1] = 0, ans -= count[y1];
if (a[i] != 0) {
merge(x0, x1);
merge(y0, y1);
} else {
merge(x0, y1);
merge(x1, y0);
}
int x = find(u), y = find(u + k);
if (x == True || y == True) {
vis[True] = 1;
ans += count[True];
} else {
int t = count[x] < count[y] ? x : y;
vis[t] = 1;
ans += count[t];
}
}
}
printf("%d\n", ans);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long sz[3000009], par[3000009];
long long res;
long long n, k;
std::vector<long long> pos[3000009];
long long getparent(long long x) {
if (par[x] == x) return x;
return par[x] = getparent(par[x]);
}
void merge(long long x, long long y) {
long long p1 = getparent(x);
long long p2 = getparent(y);
if (p1 == p2) return;
par[p1] = p2;
res -= min(sz[p1], sz[p1 ^ 1]);
res -= min(sz[p2], sz[p2 ^ 1]);
sz[p2] += sz[p1];
res += min(sz[p2], sz[p2 ^ 1]);
sz[p1] = 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
string x;
cin >> x;
for (long long int i = 0; i < 2 * k + 2; i++) {
par[i] = i;
sz[i] = (i) % 2;
}
for (long long int i = 0; i < k; i++) {
long long ss;
cin >> ss;
for (long long int j = 0; j < ss; j++) {
long long yy;
cin >> yy;
yy--;
pos[yy].push_back(i);
}
}
for (long long int i = 0; i < n; i++) {
if (pos[i].size() == 0) {
cout << res << '\n';
continue;
}
if (pos[i].size() == 1) {
if (x[i] == '1') {
long long pp = getparent(2 * pos[i][0] + 1);
res -= min(sz[pp], sz[pp ^ 1]);
sz[pp] = 1e7;
res += sz[pp ^ 1];
} else {
long long pp = getparent(2 * pos[i][0]);
res -= min(sz[pp], sz[pp ^ 1]);
sz[pp] = 1e7;
res += sz[pp ^ 1];
}
cout << res << '\n';
continue;
}
if (x[i] == '1') {
merge(2 * pos[i][0], 2 * pos[i][1]);
merge((2 * pos[i][0]) + 1, (2 * pos[i][1]) + 1);
} else {
merge(2 * pos[i][0], (2 * pos[i][1]) + 1);
merge((2 * pos[i][0]) + 1, 2 * pos[i][1]);
}
cout << res << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 3e5 + 5;
long long inf = (long long)30000;
long long mod = (long long)998244353;
long long ans = 0, vert;
long long n, k, par[MAX], sz[MAX], cnt[MAX][2], clr[MAX], pos[MAX];
vector<long long> sets[MAX];
vector<long long> b[MAX];
void x_or(long long dad) {
for (int i = 0; i < sets[dad].size(); i++) {
clr[sets[dad][i]] ^= 1;
}
cnt[dad][0] = 0;
cnt[dad][1] = 0;
for (int i = 0; i < sets[dad].size(); i++) {
long long v = sets[dad][i];
if (clr[v] == 0)
cnt[dad][0]++;
else
cnt[dad][1]++;
}
}
long long get(long long u) {
if (par[u] == u)
return u;
else {
long long v = get(par[u]);
par[u] = v;
return v;
}
}
void unite(long long a, long long b) {
if (get(a) == get(b)) return;
if (sz[get(a)] < sz[get(b)]) swap(a, b);
if (vert == 1 && clr[a] != clr[b]) x_or(get(b));
if (vert == 0 && clr[a] == clr[b]) x_or(get(b));
a = get(a);
b = get(b);
for (int i = 0; i < sets[b].size(); i++) sets[a].push_back(sets[b][i]);
sets[b].clear();
par[b] = a;
sz[a] += sz[b];
ans -= min(cnt[b][0], cnt[b][1]) + min(cnt[a][0], cnt[a][1]);
cnt[a][0] += cnt[b][0];
cnt[a][1] += cnt[b][1];
ans += min(cnt[a][0], cnt[a][1]);
}
void unite_1(long long v, long long u) {
if (vert == 1 && clr[v] != clr[u]) x_or(get(u));
if (vert == 0 && clr[v] == clr[u]) x_or(get(u));
v = get(v);
u = get(u);
par[u] = v;
for (int i = 0; i < sets[u].size(); i++) {
sets[v].push_back(sets[u][i]);
}
sets[u].clear();
ans -= min(cnt[u][1], cnt[u][0]);
ans += cnt[u][1];
cnt[v][1] += cnt[u][1];
cnt[v][0] += cnt[u][0];
}
void solve() {
cin >> n >> k;
string s;
cin >> s;
for (int i = 1; i <= k; i++) {
long long c;
cin >> c;
for (int j = 0; j < c; j++) {
long long a;
cin >> a;
b[a].push_back(i);
}
}
for (int i = 1; i <= k; i++) {
sz[i] = 1;
clr[i] = 0;
cnt[i][0] = 1;
par[i] = i;
sets[i].push_back(i);
}
for (int i = 1; i <= n; i++) {
vert = s[i - 1] - 48;
if (b[i].size() == 1 && !pos[get(b[i][0])]) {
long long v = b[i][0];
if (clr[v] == 0 && vert == 0) x_or(get(v));
if (clr[v] == 1 && vert == 1) x_or(get(v));
ans -= min(cnt[get(v)][0], cnt[get(v)][1]);
ans += cnt[get(v)][1];
pos[get(v)] = 1;
} else if (b[i].size() == 2) {
if (pos[get(b[i][0])] || pos[get(b[i][1])]) {
if (pos[get(b[i][0])] && pos[get(b[i][1])])
;
else {
long long u, v;
v = b[i][0];
u = b[i][1];
if (pos[get(b[i][1])]) swap(u, v);
unite_1(v, u);
}
} else {
unite(b[i][0], b[i][1]);
}
}
cout << ans << "\n";
}
}
int main() {
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ios::sync_with_stdio(0);
long long q;
q = 1;
while (q--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct perem {
long long t = 0, l = 1, p = -1, q = 0;
};
ifstream fin("AAtest.in.txt");
long long n, k, m, c, vas, cc = 1000000;
vector<long long> vv;
string s;
vector<vector<long long>> la;
vector<perem> pr;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k >> s;
la.resize(n, vector<long long>(0));
pr.resize(k);
for (int(i) = (0); ((i)) < ((k)); ((i))++) {
cin >> m;
for (int(j) = (0); ((j)) < ((m)); ((j))++) {
cin >> c;
la[c - 1].emplace_back(i);
}
}
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
vas = 0;
if (la[i].size() > 0) {
long long a = la[i][0];
bool b1 = 0;
while (a != -1) {
b1 ^= pr[a].q;
if (pr[a].p != -1)
a = pr[a].p;
else
break;
}
if (la[i].size() == 1) {
if ((b1 and s[i] == '1') or (!b1 and s[i] == '0')) {
vas += pr[a].l;
pr[a].q ^= 1;
}
pr[a].l = cc;
} else {
long long b = la[i][1];
bool b2 = 0;
while (b != -1) {
b2 ^= pr[b].q;
if (pr[b].p != -1)
b = pr[b].p;
else
break;
}
if (a != b) {
b1 ^= b2;
long long kl = 0;
if ((b1 and s[i] == '1') or (!b1 and s[i] == '0')) {
if (pr[a].l < pr[b].l) {
vas += pr[a].l;
pr[a].q ^= 1;
} else {
vas += pr[b].l;
pr[b].q ^= 1;
}
kl = abs(pr[a].l - pr[b].l);
} else
kl = min(pr[a].l + pr[b].l, cc);
if (pr[a].t < pr[b].t) swap(a, b);
if (pr[a].q) pr[b].q ^= 1;
if (pr[a].t == pr[b].t) pr[a].t++;
pr[a].l = kl;
pr[b].p = a;
}
}
}
if (i)
vv.emplace_back(vv.back() + vas);
else
vv.emplace_back(vas);
}
for (long long i : vv) cout << i << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 100;
vector<int> v[N];
int father[N], cnt[N], k;
int Find(int x) { return father[x] = father[x] == x ? x : Find(father[x]); }
void unite(int x, int y) {
int tx = Find(x);
int ty = Find(y);
if (tx == ty) return;
father[tx] = ty;
cnt[ty] += cnt[tx];
}
int calc(int x) { return min(cnt[Find(x)], cnt[Find(x + k)]); }
int main() {
int n, x, m;
string s;
cin >> n >> k;
cin >> s;
for (int i = 1; i <= k; i++) {
cin >> m;
while (m--) {
cin >> x;
x--;
v[x].push_back(i);
}
father[i] = i;
father[i + k] = i + k;
cnt[i] = 1;
}
father[2 * k + 1] = 2 * k + 1;
cnt[2 * k + 1] = (int)1e9;
int ans = 0;
for (int i = 0; i < n; i++) {
if ((int)v[i].size() == 1) {
int to = v[i][0] + k * (s[i] == '0');
ans -= calc(v[i][0]);
unite(to, 2 * k + 1);
ans += calc(v[i][0]);
} else if ((int)v[i].size() == 2) {
int x = v[i][0];
int y = v[i][1];
if (s[i] == '1' && Find(x) != Find(y)) {
ans -= calc(x) + calc(y);
unite(x, y);
unite(x + k, y + k);
ans += calc(x);
}
if (s[i] == '0' && Find(x) != Find(y + k)) {
ans -= calc(x) + calc(y);
unite(x, y + k);
unite(x + k, y);
ans += calc(x);
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct perem {
int t = 0, l = 1, p = -1, q = 0;
};
ifstream fin("AAtest.in.txt");
long long n, k, m, c, vas, cc = 10000;
vector<long long> vv;
string s;
vector<vector<long long>> la;
vector<perem> pr;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k >> s;
la.resize(n, vector<long long>(0));
pr.resize(k);
for (int(i) = (0); ((i)) < ((k)); ((i))++) {
cin >> m;
for (int(j) = (0); ((j)) < ((m)); ((j))++) {
cin >> c;
la[c - 1].emplace_back(i);
}
}
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
vas = 0;
if (la[i].size() == 2) {
long long a = la[i][0], b = la[i][1];
bool b1 = 0;
while (a != -1) {
b1 ^= pr[a].q;
if (pr[a].p != -1)
a = pr[a].p;
else
break;
}
bool b2 = 0;
while (b != -1) {
b2 ^= pr[b].q;
if (pr[b].p != -1)
b = pr[b].p;
else
break;
}
if (a != b) {
b1 ^= b2;
int kl = 0;
if ((b1 and s[i] == '1') or (!b1 and s[i] == '0')) {
if (pr[a].l < pr[b].l) {
vas += pr[a].l;
pr[a].q ^= 1;
} else {
vas += pr[b].l;
pr[b].q ^= 1;
}
kl = abs(pr[a].l - pr[b].l);
} else {
kl = pr[a].l + pr[b].l;
}
if (pr[a].t < pr[b].t) swap(a, b);
if (pr[a].q) pr[b].q ^= 1;
if (pr[a].t == pr[b].t) pr[a].t++;
pr[a].l = kl;
pr[b].p = a;
}
} else if (la[i].size() == 1) {
bool b = 0;
int a = la[i][0];
while (a != -1) {
b ^= pr[a].q;
if (pr[a].p != -1)
a = pr[a].p;
else
break;
}
if ((b and s[i] == '1') or (!b and s[i] == '0')) {
vas += pr[a].l;
pr[a].q ^= 1;
}
pr[a].l = cc;
}
if (i)
vv.emplace_back(vv.back() + vas);
else
vv.emplace_back(vas);
}
for (long long i : vv) cout << i << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5;
const int oo = 1e7 + 5;
int du[] = {-1, 0, 0, 1};
int dv[] = {0, -1, 1, 0};
const long long mod = 1e9 + 7;
long long sqr(long long x) { return x * x; }
int getbit(int state, int i) { return ((state >> i) & 1); }
int n, m, res, dad[N + 5];
vector<int> g[N + 5];
char s[N + 5];
struct Clara {
int l, r, state;
Clara(int L = 0, int R = 0, int State = 0) {
l = L;
r = R;
state = State;
}
int getmin() { return min(l, r); }
void add(Clara tmp) {
l = min(oo, l + tmp.l);
r = min(oo, r + tmp.r);
}
} node[N + 5];
pair<int, int> getdad(int u) {
if (dad[u] < 0) return pair<int, int>(u, 0);
pair<int, int> tmp = getdad(dad[u]);
dad[u] = tmp.first;
node[u].state ^= tmp.second;
return pair<int, int>(tmp.first, node[u].state);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> (s + 1);
for (int i = 1; i <= m; i++) {
int c, k;
node[i] = Clara(1, 0, 0);
dad[i] = -1;
cin >> c;
for (int j = 1; j <= c; j++) {
cin >> k;
g[k].push_back(i);
}
}
for (int i = 1; i <= n; i++) {
int type = s[i] - '0';
if (g[i].size() == 1) {
pair<int, int> u = getdad(g[i][0]);
res -= node[u.first].getmin();
if ((!type && !u.second) || (type && u.second))
node[u.first].add(Clara(0, oo, 0));
else
node[u.first].add(Clara(oo, 0, 0));
res += node[u.first].getmin();
} else if (g[i].size() == 2) {
pair<int, int> u = getdad(g[i][0]);
pair<int, int> v = getdad(g[i][1]);
if (u.first != v.first) {
res -= node[u.first].getmin() + node[v.first].getmin();
if (dad[u.first] > dad[v.first]) swap(u, v);
if ((type && u.second != v.second) || (!type && u.second == v.second)) {
swap(node[v.first].l, node[v.first].r);
node[v.first].state = 1;
}
node[u.first].add(node[v.first]);
dad[u.first] += dad[v.first];
dad[v.first] = u.first;
res += node[u.first].getmin();
}
}
cout << res << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300000 + 10;
const int apsz = 26;
const int INF = 10000007;
const unsigned long long mod = 97;
const int maxm = 10000 + 10;
int n, k;
char s[maxn];
int st[maxn];
vector<int> epos[maxn];
int cnt[maxn << 1];
int fa[maxn << 1];
int fd(int x) { return x == fa[x] ? x : fa[x] = fd(fa[x]); }
inline int calc(int x) {
int y = x + k;
x = fd(x), y = fd(y);
if (y == 0 || x == 0) return cnt[x + y];
return min(cnt[x], cnt[y]);
}
void merge(int x, int y) {
x = fd(x), y = fd(y);
if (x == y) return;
if (y == 0) swap(x, y);
fa[y] = x;
if (x) cnt[x] += cnt[y];
}
int main(void) {
scanf("%d", &(n)), scanf("%d", &(k));
scanf("%s", s + 1);
for (int i = (1); i <= (n); ++i) st[i] = s[i] - '0';
for (int i = (1); i <= (k); ++i) {
int sz, x;
scanf("%d", &(sz));
for (; sz--;) {
scanf("%d", &(x));
epos[x].push_back(i);
}
}
for (int i = (1); i <= (k * 2); ++i) fa[i] = i;
for (int i = (1); i <= (k); ++i) cnt[i] = 1;
int ans = 0;
for (int i = (1); i <= (n); ++i) {
if (epos[i].size() == 1) {
int u = epos[i][0];
ans -= calc(u);
if (st[i] == 0)
fa[fd(u + k)] = 0;
else
fa[fd(u)] = 0;
ans += calc(u);
} else if (epos[i].size() == 2) {
int y, x;
x = epos[i][0], y = epos[i][1];
if (st[i] == 1) {
if (fd(x) != fd(y) || fd(x + k) != fd(y + k)) {
ans -= calc(x) + calc(y);
merge(x, y), merge(x + k, y + k);
ans += calc(x);
}
} else {
if (fd(x) != fd(y + k) || fd(y) != fd(x + k)) {
ans -= calc(x) + calc(y);
merge(x + k, y), merge(y + k, x);
ans += calc(x);
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 600005, INF = 1000000000;
int N, K, a[MAXN];
vector<int> V[MAXN];
char S[MAXN];
int fa[MAXN], val[MAXN], ans;
int get(int x) {
if (fa[x] != x) fa[x] = get(fa[x]);
return fa[x];
}
void merge(int x, int y) {
x = get(x), y = get(y);
if (x != y) fa[x] = y, val[y] += val[x];
}
inline int va(int x) { return min(val[get(x)], val[get(x + K)]); }
int main() {
scanf("%d%d%s", &N, &K, S + 1);
int i, j;
for (i = 1; i <= K; ++i) {
int c, x;
scanf("%d", &c);
while (c--) scanf("%d", &x), V[x].push_back(i);
}
for (i = 1; i <= K * 2; ++i) fa[i] = i, val[i] = i > K;
fa[K * 2 + 1] = K * 2 + 1, val[K * 2 + 1] = INF;
for (i = 1; i <= N; ++i) {
if (V[i].size() == 1) {
int x = V[i][0] + (S[i] == '1') * K;
ans -= va(V[i][0]), merge(x, K * 2 + 1), ans += va(V[i][0]);
} else if (V[i].size() == 2) {
int x = V[i][0], y = V[i][1];
if (S[i] == '0') {
if (get(x) != get(y + K))
ans -= va(x) + va(y), merge(x, y + K), merge(x + K, y), ans += va(x);
} else {
if (get(x) != get(y))
ans -= va(x) + va(y), merge(x, y), merge(x + K, y + K), ans += va(x);
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> vec[300005];
int par[300005], sz[300005], bit[300005], sister[300005], ans;
int find(int node) {
if (par[node] == node) return node;
par[node] = par[par[node]];
return find(par[node]);
}
int Union(int a, int b) {
if (!b) return a;
if (sz[a] < sz[b]) swap(a, b);
par[b] = a;
sz[a] += sz[b];
bit[a] = max(bit[b], bit[a]);
return a;
}
void adjustans(int node1, int node2) {
if (!node2) {
if (bit[node1] == 1) ans -= sz[node1];
return;
}
if (bit[node1] == -1 && bit[node2] == -1)
ans -= min(sz[node1], sz[node2]);
else if (bit[node1] == 1)
ans -= sz[node1];
else if (bit[node2] == 1)
ans -= sz[node2];
}
void connect(int node1, int node2, bool flag) {
int a = find(node1);
int b = find(node2);
if (a == b || sister[a] == b) return;
adjustans(a, sister[a]);
adjustans(b, sister[b]);
int A, B;
if (!flag) {
A = Union(b, sister[a]);
B = Union(a, sister[b]);
} else {
A = Union(a, b);
if (!sister[a] && !sister[b]) {
if (bit[A] == 1) ans += sz[A];
return;
} else if (!sister[a])
B = Union(sister[b], sister[a]);
else
B = Union(sister[a], sister[b]);
}
sister[A] = B;
sister[B] = A;
if (bit[A] == -1 && bit[B] == -1)
ans += min(sz[A], sz[B]);
else if (bit[A] == 1 || !bit[B]) {
bit[A] = 1;
bit[B] = 0;
ans += sz[A];
} else if (!bit[A] || bit[B] == 1) {
bit[A] = 0;
bit[B] = 1;
ans += sz[B];
}
}
int main() {
memset(bit, -1, sizeof(bit));
int n, k, c, x;
string str;
cin >> n >> k;
cin >> str;
for (int i = 1; i <= k; ++i) {
par[i] = i;
sz[i] = 1;
cin >> c;
while (c--) {
cin >> x;
vec[x].push_back(i);
}
}
for (int i = 1; i <= n; ++i) {
if (vec[i].size() == 1) {
int val = find(vec[i][0]);
if (str[i - 1] == '0' && bit[val] == -1) {
if (!sister[val])
ans += sz[val];
else {
ans += (sz[val] - min(sz[val], sz[sister[val]]));
bit[sister[val]] = 0;
}
bit[val] = 1;
} else if (str[i - 1] == '1' && bit[val] == -1) {
bit[val] = 0;
if (sister[val]) {
bit[sister[val]] = 1;
ans += (sz[sister[val]] - min(sz[val], sz[sister[val]]));
}
}
} else if (vec[i].size() == 2) {
if (str[i - 1] == '0')
connect(vec[i][0], vec[i][1], 0);
else
connect(vec[i][0], vec[i][1], 1);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, K, p[301000], tot, UF[301000], UP[301000], C[301000][2], T[301000];
char s[301000];
vector<int> g[301000], u[301000];
int Find(int a) {
int x = a, s = 0;
while (x != UF[x]) {
s ^= UP[x];
x = UF[x];
}
int t = 0, root = x;
x = a;
while (x != UF[x]) {
int y = UF[x];
int z = UP[x];
UP[x] = t ^ s;
UF[x] = root;
t ^= z;
x = y;
}
return root;
}
int Get(int a) {
if (!T[a]) return min(C[a][0], C[a][1]);
return C[a][!(T[a] - 2)];
}
void Minus(int a) { tot -= Get(a); }
void Plus(int a) { tot += Get(a); }
void f1(int a, int c) {
int x = Find(a);
int d = UP[a];
int ck = d ^ c;
Minus(x);
T[x] = ck + 2;
Plus(x);
}
void f2(int a, int b, int c) {
int r1 = Find(a), r2 = Find(b);
int d1 = UP[a], d2 = UP[b];
int d = d1 ^ d2 ^ c;
if (r1 == r2) return;
Minus(r1);
Minus(r2);
C[r1][0] += C[r2][d];
C[r1][1] += C[r2][d ^ 1];
if (!T[r1] && T[r2]) {
T[r1] = ((T[r2] - 2) ^ d) + 2;
}
UF[r2] = r1;
UP[r2] = d;
Plus(r1);
}
void Process() {
int i, j;
scanf("%d%d", &n, &K);
scanf("%s", s + 1);
for (i = 1; i <= K; i++) {
int sz;
scanf("%d", &sz);
g[i].resize(sz);
for (j = 0; j < sz; j++) {
scanf("%d", &g[i][j]);
u[g[i][j]].push_back(i);
}
}
for (i = 1; i <= K; i++) UF[i] = i, C[i][0] = 1;
for (i = 1; i <= n; i++) {
int c = '1' - s[i];
if (u[i].empty()) {
} else if (u[i].size() == 1) {
f1(u[i][0], c);
} else {
int a = u[i][0], b = u[i][1];
f2(a, b, c);
}
printf("%d\n", tot);
}
}
int main() {
int Tcase = 1;
while (Tcase--) {
Process();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const int inf = 1e9;
int d[maxn], fa[maxn];
int n, k;
char s[maxn];
vector<int> vec[maxn];
int get(int x) {
if (x == fa[x]) return x;
return fa[x] = get(fa[x]);
}
void merge(int x, int y) {
int fx = get(x), fy = get(y);
if (fx != fy) {
fa[fx] = fy;
d[fy] += d[fx];
}
}
int val(int x) { return min(d[get(x)], d[get(x + k)]); }
int main() {
scanf("%d%d%s", &n, &k, s + 1);
for (int i = 1; i <= k; i++) {
int t, x;
scanf("%d", &t);
while (t--) scanf("%d", &x), vec[x].push_back(i);
}
for (int i = 1; i <= 2 * k; i++) fa[i] = i, d[i] = i > k;
fa[2 * k + 1] = 2 * k + 1;
d[2 * k + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vec[i].size() == 1) {
int x = vec[i][0];
ans -= val(x);
merge(x + (s[i] == '1' ? k : 0), 2 * k + 1);
ans += val(x);
} else if (vec[i].size() == 2) {
int x = vec[i][0], y = vec[i][1];
if (s[i] == '1' && get(x) != get(y)) {
ans -= val(x) + val(y);
merge(x, y), merge(x + k, y + k);
ans += val(x);
} else if (s[i] == '0' && get(x) != get(y + k)) {
ans -= val(x) + val(y);
merge(x, y + k), merge(x + k, y);
ans += val(x);
}
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct perem {
long long t = 0, l = 1, p = -1, q = 0;
};
ifstream fin("AAtest.in.txt");
long long n, k, m, c, vas, cc = 1000000;
vector<long long> vv;
string s;
vector<vector<long long>> la;
vector<perem> pr;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k >> s;
la.resize(n, vector<long long>(0));
pr.resize(k);
for (int(i) = (0); ((i)) < ((k)); ((i))++) {
cin >> m;
for (int(j) = (0); ((j)) < ((m)); ((j))++) {
cin >> c;
la[c - 1].emplace_back(i);
}
}
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
vas = 0;
if (la[i].size() > 0) {
long long a = la[i][0];
bool b1 = s[i] == '1' ? 1 : 0;
while (a != -1) {
b1 ^= pr[a].q;
if (pr[a].p != -1)
a = pr[a].p;
else
break;
}
if (la[i].size() == 1) {
if (!b1) {
vas += pr[a].l;
pr[a].q ^= 1;
}
pr[a].l = cc;
} else {
long long b = la[i][1];
while (b != -1) {
b1 ^= pr[b].q;
if (pr[b].p != -1)
b = pr[b].p;
else
break;
}
if (a != b) {
long long kl = 0;
if (!b1) {
if (pr[a].l < pr[b].l) {
vas += pr[a].l;
pr[a].q ^= 1;
} else {
vas += pr[b].l;
pr[b].q ^= 1;
}
kl = abs(pr[a].l - pr[b].l);
} else
kl = min(pr[a].l + pr[b].l, cc);
if (pr[a].t < pr[b].t) swap(a, b);
if (pr[a].q) pr[b].q ^= 1;
if (pr[a].t == pr[b].t) pr[a].t++;
pr[a].l = kl;
pr[b].p = a;
}
}
}
if (i)
vv.emplace_back(vv.back() + vas);
else
vv.emplace_back(vas);
}
for (long long i : vv) cout << i << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, k, s, x, op[N][2];
char ch[N];
int p[N << 1], val[N << 1];
int find(int u) { return p[u] == u ? p[u] : p[u] = find(p[u]); }
void merge(int a, int b) {
if (a == b) return;
val[b] += val[a];
p[a] = b;
}
int main() {
scanf("%d%d%s", &n, &k, ch + 1);
for (int i = 1; i <= k; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
op[x][bool(op[x][0])] = i;
}
}
for (int i = 1; i <= k; i++) val[i] = 1, p[i] = i, p[i + k] = i + k;
p[k + k + 1] = k + k + 1;
val[k + k + 1] = inf;
int now = 0;
for (int i = 1; i <= n; i++) {
if (op[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (op[i][1]) {
if (find(op[i][0]) == find(op[i][1])) goto qwq;
now -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
now -= min(val[find(op[i][1])], val[find(op[i][1] + k)]);
merge(find(op[i][0]), find(op[i][1]));
merge(find(op[i][0] + k), find(op[i][1] + k));
now += min(val[find(op[i][1])], val[find(op[i][1] + k)]);
} else {
now -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
merge(find(op[i][0]), find(k + k + 1));
now += val[find(op[i][0] + k)];
}
} else {
if (op[i][1]) {
if (find(op[i][0]) == find(op[i][1] + k)) goto qwq;
now -= min(val[find(op[i][1])], val[find(op[i][1] + k)]);
now -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
merge(find(op[i][0]), find(op[i][1] + k)),
merge(find(op[i][1]), find(op[i][0] + k));
now += min(val[find(op[i][1] + k)], val[find(op[i][0] + k)]);
} else {
now -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
merge(find(op[i][0] + k), find(k + k + 1));
now += val[find(op[i][0])];
}
}
qwq:
printf("%d\n", now);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-10;
const int MOD = 998857459;
const int INF = 0x3f3f3f3f;
const int maxn = 3e5 + 10;
const int maxm = 5e6 + 10;
int n, k, op[maxn][2], p[maxn << 1], val[maxn << 1];
char str[maxn];
int find(int first) {
return p[first] == first ? p[first] : p[first] = find(p[first]);
}
void merge(int first, int second) {
if (first == second) return;
val[second] += val[first];
p[first] = second;
}
int main() {
cin >> n >> k;
scanf("%s", str + 1);
for (int i = 1, sz, a; i <= k; ++i) {
scanf("%d", &sz);
while (sz--) {
scanf("%d", &a);
op[a][bool(op[a][0])] = i;
}
val[i] = 1;
p[i] = i;
p[i + k] = i + k;
}
val[0] = INF;
int now = 0;
for (int i = 1; i <= n; ++i) {
int fa = find(op[i][0]), fb = find(op[i][1]);
int rfa = find(op[i][0] + k), rfb = find(op[i][1] + k);
if (!op[i][0]) goto out;
if (str[i] == '1') {
if (op[i][1]) {
if (fa == fb) goto out;
now -= min(val[fa], val[rfa]);
now -= min(val[fb], val[rfb]);
merge(fa, fb);
merge(rfa, rfb);
now += min(val[fb], val[rfb]);
} else {
now -= min(val[fa], val[rfa]);
merge(fa, find(0));
now += val[rfa];
}
} else {
if (op[i][1]) {
if (fa == rfb) goto out;
now -= min(val[fa], val[rfa]);
now -= min(val[fb], val[rfb]);
merge(fa, rfb);
merge(fb, rfa);
now += min(val[rfb], val[rfa]);
} else {
now -= min(val[fa], val[rfa]);
merge(rfa, find(0));
now += val[fa];
}
}
out:
printf("%d\n", now);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, kk, s, x, k[N][2];
char ch[N];
int fa[N << 1], val[N << 1];
int find(int u) { return fa[u] == u ? fa[u] : fa[u] = find(fa[u]); }
void uni(int a, int b) {
if (find(a) == find(b)) return;
val[find(b)] += val[find(a)];
fa[find(a)] = find(b);
}
int mix(int a) { return min(val[find(a)], val[find(a + kk)]); };
int main() {
scanf("%d%d%s", &n, &kk, ch + 1);
for (int i = 1; i <= kk; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
k[x][bool(k[x][0])] = i;
}
}
for (int i = 1; i <= kk; i++) val[i] = 1, fa[i] = i, fa[i + kk] = i + kk;
fa[kk + kk + 1] = kk + kk + 1;
val[kk + kk + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (k[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1])) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1]), uni(k[i][0] + kk, k[i][1] + kk);
ans += min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0], kk + kk + 1);
ans += val[find(k[i][0] + kk)];
}
} else {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1] + kk)) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1] + kk), uni(k[i][1], k[i][0] + kk);
ans += min(val[find(k[i][1] + kk)], val[find(k[i][0] + kk)]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0] + kk, kk + kk + 1);
ans += val[find(k[i][0])];
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long double PI = 3.141592653589793238462643383279502884197;
long long fac[1] = {1}, inv[1] = {1};
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long mp(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return ret;
}
long long cmb(long long r, long long c) {
return (c > r || c < 0) ? 0 : fac[r] * inv[c] % MOD * inv[r - c] % MOD;
}
char s[300001];
vector<int> v[300000];
int p[600001];
int rotn[600001];
char vis[600001];
int find(int a) {
if (p[a] == -1) return a;
return p[a] = find(p[a]);
}
void merge(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
if (a > b) swap(a, b);
p[b] = a;
rotn[a] = min((int)1e9, rotn[b] + rotn[a]);
}
int main() {
memset(p, -1, sizeof(p));
int n, k;
scanf("%d %d", &n, &k);
scanf("%s", s);
for (int i = 0; i < n; i++) s[i] -= '0';
for (int i = 0; i < k; i++) rotn[i] = 1;
for (int i = 0; i < k; i++) {
int t;
scanf("%d", &t);
for (int j = 0; j < t; j++) {
int tt;
scanf("%d", &tt);
tt--;
v[tt].push_back(i);
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j : v[i]) {
if (vis[find(j)]) ans -= rotn[find(j)], vis[find(j)] = 0;
if (vis[find(j + k)]) ans -= rotn[find(j + k)], vis[find(j + k)] = 0;
}
if (s[i] == 0) {
if ((int)(v[i]).size() == 2) {
merge(v[i][0] + k, v[i][1]);
merge(v[i][0], v[i][1] + k);
} else
rotn[find(v[i][0] + k)] = 1e9;
} else {
if ((int)(v[i]).size() == 2) {
merge(v[i][0], v[i][1]);
merge(v[i][0] + k, v[i][1] + k);
} else if ((int)(v[i]).size() == 1)
rotn[find(v[i][0])] = 1e9;
}
for (int j : v[i]) {
if (vis[find(j)] || vis[find(j + k)]) continue;
int ne;
if (rotn[find(j)] > rotn[find(j + k)])
ne = find(j + k);
else
ne = find(j);
vis[ne] = 1;
ans += rotn[ne];
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
const int lim = 1000 * 1000 + 5;
int nbElem, nbSub;
vector<int> subset[lim];
int side[lim];
int isIn[lim][2];
string ini;
int rep = 0;
int drepr[lim];
int dsz[lim];
int cnt[lim][2];
int dfind(int x) {
if (drepr[x] != x) drepr[x] = dfind(drepr[x]);
return drepr[x];
}
void add(int cc, int s0, int s1) {
cc = dfind(cc);
rep -= min(cnt[cc][0], cnt[cc][1]);
cnt[cc][0] = min(lim, cnt[cc][0] + s0);
cnt[cc][1] = min(lim, cnt[cc][1] + s1);
rep += min(cnt[cc][0], cnt[cc][1]);
}
void dmerge(int a, int b) {
a = dfind(a);
b = dfind(b);
if (a == b) return;
if (dsz[a] < dsz[b]) swap(a, b);
add(a, cnt[b][0], cnt[b][1]);
add(b, -cnt[b][0], -cnt[b][1]);
dsz[a] += dsz[b];
drepr[b] = a;
}
void dfs(int nod) {
cnt[nod][side[nod]] = 1;
for (int elem : subset[nod]) {
if (isIn[elem][1] == -1) continue;
int oth = isIn[elem][0] + isIn[elem][1] - nod;
if (side[oth] == -1) {
side[oth] = side[nod] ^ (ini[elem] == '0');
dfs(oth);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> nbElem >> nbSub;
cin >> ini;
fill(side, side + lim, -1);
iota(drepr, drepr + lim, 0);
fill_n(&isIn[0][0], 2 * lim, -1);
for (int sub = 0; sub < nbSub; ++sub) {
int st;
cin >> st;
subset[sub].resize(st);
for (int pos = 0; pos < st; ++pos) {
int elem;
cin >> elem;
--elem;
subset[sub][pos] = elem;
if (isIn[elem][0] == -1)
isIn[elem][0] = sub;
else
isIn[elem][1] = sub;
}
}
for (int sub = 0; sub < nbSub; ++sub) {
if (side[sub] == -1) {
side[sub] = 0;
dfs(sub);
}
}
for (int elem = 0; elem < nbElem; ++elem) {
int n0 = isIn[elem][0], n1 = isIn[elem][1];
if (n0 != -1 && n1 == -1) {
int destroy = side[n0] ^ (ini[elem] == '0');
if (destroy == 1)
add(n0, 0, lim);
else
add(n0, lim, 0);
} else if (n0 != -1) {
dmerge(n0, n1);
}
cout << rep << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int MAXN = N;
const int mx = 5e5;
const int inf = 1e9;
int arr[MAXN];
vector<int> v1[MAXN];
struct DSU {
int tot = 0;
int par[MAXN];
int cost[MAXN];
void init() {
for (int i = 0; i < N; i++) {
par[i] = i;
cost[i] = (i % 2 == 0);
}
cost[2 * mx] = 0;
cost[2 * mx + 1] = inf;
tot = 0;
}
int getpar(int a) {
if (par[a] == a) {
return a;
}
return par[a] = getpar(par[a]);
}
void merge(int a, int b, int curr) {
int a_true = 2 * a;
int b_true = 2 * b;
int a_false = 2 * a + 1;
int b_false = 2 * b + 1;
a_true = getpar(a_true);
a_false = getpar(a_false);
b_true = getpar(b_true);
b_false = getpar(b_false);
if (curr) {
if (a_true == b_true) {
return;
}
tot -= min(cost[a_true], cost[a_false]);
tot -= min(cost[b_true], cost[b_false]);
cost[b_true] += cost[a_true];
cost[b_false] += cost[a_false];
par[a_true] = b_true;
par[a_false] = b_false;
} else {
if (a_true == b_false) {
return;
}
tot -= min(cost[a_true], cost[a_false]);
tot -= min(cost[b_true], cost[b_false]);
cost[b_false] += cost[a_true];
cost[b_true] += cost[a_false];
par[a_false] = b_true;
par[a_true] = b_false;
}
tot += min(cost[b_true], cost[b_false]);
}
} dsu;
int main() {
int n, k;
cin >> n >> k;
string str;
cin >> str;
for (int i = 1; i <= n; i++) {
arr[i] = str[i - 1] - '0';
}
for (int i = 1; i <= k; i++) {
int c;
cin >> c;
while (c--) {
int a;
cin >> a;
v1[a].push_back(i);
}
}
dsu.init();
for (int i = 1; i <= n; i++) {
if (v1[i].size() == 1) {
dsu.merge(v1[i][0], mx, arr[i] == 0);
} else if (v1[i].size() == 2) {
dsu.merge(v1[i][0], v1[i][1], arr[i] == 1);
}
cout << dsu.tot << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct UF {
vector<int> e;
UF(int n) : e(n, -1) {}
int find(int x) { return e[x] < 0 ? x : e[x] = find(e[x]); }
bool join(int a, int b) {
a = find(a), b = find(b);
if (a == b) return false;
if (e[a] > e[b]) swap(a, b);
e[a] += e[b];
e[b] = a;
return true;
}
};
char s[300030];
pair<int, int> a[300030];
vector<pair<int, int>> g[300030];
int t, n, k, m, x, d[300030], cnt[3][300030], ans;
void dfs(int v, int p, int s) {
if (s)
d[v] = d[p];
else
d[v] = 3 - d[p];
for (auto u : g[v])
if (!d[u.first]) dfs(u.first, v, u.second);
}
int main() {
scanf("%d%d%s", &n, &k, s + 1);
UF uf(k + 1);
d[k + 1] = 2;
for (int i = 1; i <= n; i++) s[i] -= '0';
for (int i = 1; i <= k; i++)
for (int j = !scanf("%d", &m); j < m; j++)
if (scanf("%d", &x), a[x].first) {
a[x].second = i;
g[a[x].first].emplace_back(i, s[x]);
g[i].emplace_back(a[x].first, s[x]);
} else
a[x].first = i;
for (int i = 1; i <= n; i++)
if (a[i].first && a[i].second == 0) g[0].emplace_back(a[i].first, s[i]);
for (int i = 0; i <= k; i++)
if (!d[i]) dfs(i, k + 1, 0);
for (int i = 1; i <= k; i++) cnt[d[i]][i] = 1;
cnt[1][0] = 0x3f3f3f3f;
for (int i = 1; i <= n; i++) {
int u = uf.find(a[i].first), v = uf.find(a[i].second);
if (uf.join(u, v)) {
ans -= min(cnt[1][u], cnt[2][u]);
ans -= min(cnt[1][v], cnt[2][v]);
for (int j = 1; j <= 2; j++)
cnt[j][u] = cnt[j][v] = cnt[j][u] + cnt[j][v];
ans += min(cnt[1][u], cnt[2][u]);
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T& x) {
x = 0;
int fl = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') fl = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
x *= fl;
}
template <typename T, typename... Args>
inline void read(T& t, Args&... args) {
read(t);
read(args...);
}
const int N = 300005;
const int INF = 1e9;
int n, k, c;
vector<int> vec[N];
char s[N];
int fa[N << 1], sz[N << 1];
inline int lowbit(int x) { return x & -x; }
inline int findfa(int x) { return x == fa[x] ? x : fa[x] = findfa(fa[x]); }
inline void unionn(int x, int y) {
x = findfa(x), y = findfa(y);
fa[y] = x;
if (sz[x] < INF) sz[x] += sz[y];
}
int main() {
read(n, k);
scanf("%s", s + 1);
for (int i = 1; i <= k; i++) {
read(c);
for (int j = 1; j <= c; j++) {
int x;
read(x);
vec[x].push_back(i);
}
}
for (int i = 1; i <= k * 2; i++) fa[i] = i, sz[i] = (i <= k);
fa[k * 2 + 1] = k * 2 + 1, sz[k * 2 + 1] = INF;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vec[i].size() == 1) {
if (findfa(k * 2 + 1) != findfa(vec[i][0] + k * (s[i] == '0'))) {
ans -= min(sz[findfa(vec[i][0])], sz[findfa(vec[i][0] + k)]);
unionn(k * 2 + 1, vec[i][0] + k * (s[i] == '0'));
ans += min(sz[findfa(vec[i][0])], sz[findfa(vec[i][0] + k)]);
}
} else if (vec[i].size() == 2) {
if (s[i] == '0') {
if (findfa(vec[i][0]) != findfa(vec[i][1] + k)) {
ans -= min(sz[findfa(vec[i][0])], sz[findfa(vec[i][0] + k)]);
ans -= min(sz[findfa(vec[i][1])], sz[findfa(vec[i][1] + k)]);
unionn(vec[i][0], vec[i][1] + k);
unionn(vec[i][0] + k, vec[i][1]);
ans += min(sz[findfa(vec[i][0])], sz[findfa(vec[i][0] + k)]);
}
} else {
if (findfa(vec[i][0]) != findfa(vec[i][1])) {
ans -= min(sz[findfa(vec[i][0])], sz[findfa(vec[i][0] + k)]);
ans -= min(sz[findfa(vec[i][1])], sz[findfa(vec[i][1] + k)]);
unionn(vec[i][0], vec[i][1]);
unionn(vec[i][0] + k, vec[i][1] + k);
ans += min(sz[findfa(vec[i][0])], sz[findfa(vec[i][0] + k)]);
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 6e5 + 5;
int n, K;
char S[MAXN >> 1];
vector<int> A[MAXN];
namespace DSU {
int fa[MAXN], size[MAXN];
inline void init() {
for (int i = 1; i <= K; ++i) fa[i] = i, fa[i + K] = i + K, size[i + K] = 1;
}
int findfa(int u) { return fa[u] == u ? u : fa[u] = findfa(fa[u]); }
int calc(int u) {
int v = u <= K ? u + K : u - K;
u = findfa(u), v = findfa(v);
if (!u || !v) return size[u + v];
return min(size[u], size[v]);
}
void join(int u, int v) {
u = findfa(u), v = findfa(v);
if (!v) swap(u, v);
fa[v] = u;
if (u) size[u] += size[v];
}
} // namespace DSU
int main() {
scanf("%d%d", &n, &K);
DSU::init();
scanf("%s", S + 1);
for (int x, y, i = 1; i <= K; ++i) {
scanf("%d", &y);
while (y--) scanf("%d", &x), A[x].push_back(i);
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (A[i].size() == 1) {
int x = A[i][0];
ans -= DSU::calc(x);
if (S[i] == '0')
DSU::fa[DSU::findfa(x)] = 0;
else
DSU::fa[DSU::findfa(x + K)] = 0;
ans += DSU::calc(x);
}
if (A[i].size() == 2) {
int x = A[i][0], y = A[i][1];
if (S[i] == '0') {
if (DSU::findfa(x) != DSU::findfa(y + K)) {
ans -= DSU::calc(x) + DSU::calc(y);
DSU::join(x, y + K), DSU::join(y, x + K);
ans += DSU::calc(x);
}
} else {
if (DSU::findfa(x) != DSU::findfa(y)) {
ans -= DSU::calc(x) + DSU::calc(y);
DSU::join(x, y), DSU::join(x + K, y + K);
ans += DSU::calc(x);
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
char s[300005];
vector<int> bel[300005];
int fa[300005 * 2], val[300005 * 2];
int getfa(int now) { return fa[now] == now ? now : fa[now] = getfa(fa[now]); }
int getans(int now) {
int now2;
if (now <= k)
now2 = k + now;
else
now2 = now - k;
int xx = getfa(now), yy = getfa(now2);
if (xx == 0 || yy == 0) return val[xx + yy];
return min(val[xx], val[yy]);
}
void merge(int x, int y) {
int xx = getfa(x), yy = getfa(y);
if (xx == yy) return;
if (yy == 0) swap(xx, yy);
fa[yy] = xx;
if (xx != 0) val[xx] += val[yy];
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
for (int i = 1; i <= k; i++) {
int c;
scanf("%d", &c);
for (int j = 1; j <= c; j++) {
int x;
scanf("%d", &x);
bel[x].push_back(i);
}
fa[i] = i;
fa[i + k] = i + k;
val[i + k] = 1;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int len = bel[i].size();
if (len == 0) {
printf("%d\n", ans);
continue;
}
if (len == 1) {
int now = bel[i][0];
ans -= getans(now);
if (s[i] == '1')
fa[getfa(now + k)] = 0;
else
fa[getfa(now)] = 0;
ans += getans(now);
}
if (len == 2) {
int now1 = bel[i][0];
int now2 = bel[i][1];
if (s[i] == '1') {
if (getfa(now1) != getfa(now2)) {
ans -= getans(now1);
ans -= getans(now2);
merge(now1, now2);
merge(now1 + k, now2 + k);
ans += getans(now1);
}
} else {
if (getfa(now1 + k) != getfa(now2)) {
ans -= getans(now1);
ans -= getans(now2);
merge(now1 + k, now2);
merge(now1, now2 + k);
ans += getans(now1);
}
}
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int INF = 1000000007;
string s;
int n, k, c, v, ans;
int fat[1000100], siz[1000100];
vector<int> edge[1000100];
struct node {
int l, r, xo;
node(int _l = 0, int _r = 0, int _xo = 0) : l(_l), r(_r), xo(_xo) {}
int get() { return min(l, r); }
void operator+=(node th) {
l += th.l;
r += th.r;
if (l > INF) l = INF;
if (r > INF) r = INF;
}
} val[1000100];
pair<int, int> uu, vv;
pair<int, int> trace(int x) {
if (fat[x] < 0) return make_pair(x, 0);
pair<int, int> pp = trace(fat[x]);
fat[x] = pp.first;
val[x].xo ^= pp.second;
return make_pair(fat[x], val[x].xo);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k >> s;
s = "?" + s;
for (int i = 1; i <= k; i++) {
fat[i] = -1;
siz[i] = 1;
val[i] = node(1, 0, 0);
cin >> c;
for (int j = 1; j <= c; j++) {
cin >> v;
edge[v].push_back(i);
}
}
int ans = 0;
int id;
for (int i = 1; i <= n; i++) {
int tp = (s[i] - '0') ^ 1;
if (edge[i].size() == 1) {
id = edge[i][0];
uu = trace(id);
ans -= val[uu.first].get();
val[uu.first] += node((tp == uu.second) * INF, (tp != uu.second) * INF);
ans += val[uu.first].get();
} else if (edge[i].size() == 2) {
id = edge[i][0];
uu = trace(id);
id = edge[i][1];
vv = trace(id);
if (uu.first != vv.first) {
ans -= (val[uu.first].get() + val[vv.first].get());
if (siz[uu.first] > siz[vv.first]) swap(uu, vv);
if (uu.second ^ vv.second ^ tp) {
swap(val[vv.first].l, val[vv.first].r);
val[vv.first].xo = 1;
}
siz[uu.first] += siz[vv.first];
fat[vv.first] = uu.first;
val[uu.first] += val[vv.first];
ans += val[uu.first].get();
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char op[300005];
int n, k, fa[300005], v[300005], num[300005], sz[300005], ans, gx[300005];
vector<int> vec[300005];
int ff(int x) {
if (fa[x] == x) return x;
int f = ff(fa[x]);
v[x] ^= v[fa[x]];
return fa[x] = f;
}
inline void merge(int x, int y, int p) {
if (ff(x) == ff(y)) return;
int fx = ff(x), fy = ff(y);
if (fx == 0) swap(fx, fy);
v[fx] = p ^ v[x] ^ v[y];
sz[fy] += sz[fx];
num[fy] += v[fx] ? sz[fx] - num[fx] : num[fx];
ans -= gx[fy] + gx[fx];
if (fy == 0)
gx[fy] = num[fy];
else
gx[fy] = min(sz[fy] - num[fy], num[fy]);
ans += gx[fy], fa[fx] = fy;
}
int main() {
scanf("%d%d%s", &n, &k, op + 1);
for (int i = 0; i <= k; i++) fa[i] = i, sz[i] = 1;
for (int i = 1, c, x; i <= k; i++) {
scanf("%d", &c);
while (c--) scanf("%d", &x), vec[x].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (vec[i].size() == 1) vec[i].push_back(0);
}
for (int i = 1; i <= n; i++) {
if (!vec[i].empty()) merge(vec[i][0], vec[i][1], op[i] == '0');
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
int n, k, fa[maxn], f[maxn][2], val[maxn], pos[maxn][2], ans;
char s[maxn];
int getfa(int x) {
if (fa[x] == x) return x;
int F = fa[x];
fa[x] = getfa(F);
val[x] ^= val[F];
return fa[x];
}
void merge(int x, int y, int z) {
getfa(x), getfa(y);
z ^= (val[x] ^ val[y]);
x = fa[x], y = fa[y];
if (x == y) return;
if (x > y) swap(x, y);
if (!x)
ans -= f[x][0];
else
ans -= min(f[x][0], f[x][1]);
ans -= min(f[y][0], f[y][1]);
f[x][0] += f[y][z];
f[x][1] += f[y][z ^ 1];
fa[y] = x, val[y] = z;
if (!x)
ans += f[x][0];
else
ans += min(f[x][0], f[x][1]);
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
for (int i = 1, cnt; i <= k; i++) {
scanf("%d", &cnt);
for (int j = 1, x; j <= cnt; j++) {
scanf("%d", &x);
if (pos[x][0])
pos[x][1] = i;
else
pos[x][0] = i;
}
}
for (int i = 1; i <= k; i++) fa[i] = i, f[i][1] = 1;
for (int i = 1; i <= n; i++) {
if (!pos[i][0]) {
printf("%d\n", ans);
continue;
}
merge(pos[i][0], pos[i][1], (s[i] - '0') ^ 1);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct perem {
int t = 0, l = 1, p = -1, q = 0;
};
ifstream fin("AAtest.in.txt");
int n, k, m, c, vas, cc = 1000000, kl;
vector<int> vv;
string s;
vector<vector<int>> la;
vector<perem> pr;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k >> s;
la.resize(n, vector<int>(0));
pr.resize(k);
for (int(i) = (0); ((i)) < ((k)); ((i))++) {
cin >> m;
for (int(j) = (0); ((j)) < ((m)); ((j))++) {
cin >> c;
la[c - 1].emplace_back(i);
}
}
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
vas = 0;
if (la[i].size() > 0) {
int a = la[i][0];
bool d = s[i] == '1' ? 1 : 0;
for (;; a = pr[a].p) {
d ^= pr[a].q;
if (pr[a].p == -1) break;
}
if (la[i].size() == 1) {
if (!d) {
vas += pr[a].l;
pr[a].q ^= 1;
}
pr[a].l = cc;
} else {
int b = la[i][1];
for (;; b = pr[b].p) {
d ^= pr[b].q;
if (pr[b].p == -1) break;
}
if (a != b) {
if (!d) {
if (pr[a].l > pr[b].l) swap(a, b);
vas += pr[a].l;
pr[a].q ^= 1;
kl = abs(pr[a].l - pr[b].l);
} else
kl = min(pr[a].l + pr[b].l, cc);
if (pr[a].t < pr[b].t) swap(a, b);
if (pr[a].q) pr[b].q ^= 1;
if (pr[a].t == pr[b].t) pr[a].t++;
pr[a].l = kl;
pr[b].p = a;
}
}
}
if (i)
vv.emplace_back(vv.back() + vas);
else
vv.emplace_back(vas);
}
for (int i : vv) cout << i << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 10;
int n, k, l[maxn][2];
int fa[maxn], sz[maxn];
string s;
int get_fa(int x) {
if (x == fa[x]) return x;
return fa[x] = get_fa(fa[x]);
}
int calc(int x) {
int y = x <= k ? x + k : x - k;
x = get_fa(x), y = get_fa(y);
if (x == 0 || y == 0) return sz[x + y];
return min(sz[x], sz[y]);
}
void merge_dis(int x, int y) {
x = get_fa(x);
y = get_fa(y);
if (y == 0) {
swap(x, y);
}
fa[y] = x;
if (x != 0) sz[x] += sz[y];
}
int main() {
scanf("%d%d", &n, &k);
cin >> s;
for (int i = 1; i <= k; i++) fa[i] = i, fa[i + k] = i + k, sz[i + k] = 1;
for (int i = 1, c; i <= k; i++) {
scanf("%d", &c);
for (int j = 0, x; j < c; j++) {
scanf("%d", &x);
if (l[x][0] == 0)
l[x][0] = i;
else
l[x][1] = i;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (l[i][1] == 0) {
int x = l[i][0];
if (x) {
ans -= calc(x);
if (s[i - 1] == '1')
fa[get_fa(x + k)] = 0;
else
fa[get_fa(x)] = 0;
ans += calc(x);
}
} else {
int x = l[i][0], y = l[i][1];
if (s[i - 1] == '1') {
if (get_fa(x) != get_fa(y)) {
ans -= calc(x);
ans -= calc(y);
merge_dis(x, y);
merge_dis(x + k, y + k);
ans += calc(x);
}
} else {
if (get_fa(x + k) != get_fa(y)) {
ans -= calc(x);
ans -= calc(y);
merge_dis(x + k, y);
merge_dis(x, y + k);
ans += calc(x);
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int fa[300005];
int x[300005], y[300005];
int f[300005][2];
int a[300005][3], b[300005];
int p;
char s[300005];
int main() {
scanf("%d%d%s", &n, &m, s);
for (int i = 1; i <= m; i++) {
int ha;
scanf("%d", &ha);
while (ha--) {
int haha;
scanf("%d", &haha);
a[haha][++b[haha]] = i;
}
fa[i] = i;
f[i][0] = 1;
y[i] = -1;
}
for (int i = 1; i <= n; i++) {
if (b[i] == 1) {
int j = a[i][1];
int l = j, r = 0;
for (; fa[l] != l; l = fa[l]) r ^= x[l];
r ^= (s[i - 1] == '1');
if (y[l] == -1) {
y[l] = r;
p -= min(f[l][0], f[l][1]);
p += f[l][r];
}
} else if (b[i] == 2) {
int j = a[i][1], k = a[i][2], l = x[j], u = x[k];
while (j != fa[j]) {
j = fa[j];
l ^= x[j];
}
while (k != fa[k]) {
k = fa[k];
u ^= x[k];
}
if (j != k) {
if (f[j][0] + f[j][1] < f[k][0] + f[k][1]) swap(j, k);
if (y[j] == -1)
p -= min(f[j][0], f[j][1]);
else
p -= f[j][y[j]];
if (y[k] == -1)
p -= min(f[k][0], f[k][1]);
else
p -= f[k][y[k]];
fa[k] = j;
if (l ^ u ^ (s[i - 1] == '0')) {
x[k] = 1;
swap(f[k][0], f[k][1]);
if (y[k] != -1) y[k] ^= 1;
}
f[j][0] += f[k][0];
f[j][1] += f[k][1];
if (y[k] != -1) y[j] = y[k];
if (y[j] == -1)
p += min(f[j][0], f[j][1]);
else
p += f[j][y[j]];
}
}
printf("%d\n", p);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long poww(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * poww(a * a % md, b / 2, md) % md
: poww(a * a % md, b / 2, md) % md));
}
const long long MAXN = 1e6 + 10;
const long long INF = 8e18;
const long long MOD = 1e9 + 7;
bool Q[MAXN];
int state[MAXN], par[MAXN], c_par[MAXN], S[MAXN], C[3][MAXN], cost[MAXN],
col[MAXN], tot_cost, n, k;
vector<int> V[MAXN], BP_C[MAXN], CC_C[MAXN];
inline void Update(int v, int c, bool neg = false) {
state[v] = c;
if (c == 0) {
if (neg) tot_cost -= cost[v];
cost[v] = min(C[1][v], C[2][v]);
tot_cost += cost[v];
return;
}
if (neg) tot_cost -= cost[v];
cost[v] = C[c][v];
tot_cost += cost[v];
}
inline void Union(int v, int u, int t1, int t2) {
tot_cost -= cost[v];
tot_cost -= cost[u];
if (BP_C[v].size() > BP_C[u].size()) swap(v, u);
if (col[t1] == col[t2]) {
if (state[v]) state[v] = 3 - state[v];
for (int e : BP_C[v]) col[e] = 3 - col[e];
swap(C[1][v], C[2][v]);
}
for (int e : BP_C[v]) {
c_par[e] = u;
C[col[e]][u] += S[e];
BP_C[u].push_back(e);
}
if (state[u] == 0) state[u] = state[v];
Update(u, state[u]);
BP_C[v].clear();
C[1][v] = C[2][v] = 0;
}
inline void Union2(int v, int u) {
if (CC_C[v].size() > CC_C[u].size()) swap(v, u);
if (v == u) return;
int t1 = u, t2 = v;
u = c_par[u], v = c_par[v];
if (u != v) {
tot_cost -= cost[v];
tot_cost -= cost[u];
if (BP_C[v].size() > BP_C[u].size()) swap(v, u);
if (col[t1] != col[t2]) {
if (state[v]) state[v] = 3 - state[v];
for (int e : BP_C[v]) col[e] = 3 - col[e];
swap(C[1][v], C[2][v]);
}
C[1][u] += C[1][v];
C[2][u] += C[2][v];
for (int e : BP_C[v]) {
c_par[e] = u;
BP_C[u].push_back(e);
}
if (state[u] == 0) state[u] = state[v];
Update(u, state[u]);
BP_C[v].clear();
C[1][v] = C[2][v] = 0;
}
u = t1;
v = t2;
for (int e : CC_C[v]) {
par[e] = u;
CC_C[u].push_back(e);
}
S[u] += S[v];
S[v] = 0;
CC_C[v].clear();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
Q[i] = (c == '1');
}
for (int i = 1; i <= k; i++) {
int c;
cin >> c;
while (c--) {
int e;
cin >> e;
V[e].push_back(i);
}
par[i] = i;
CC_C[i].push_back(i);
S[i] = 1;
col[i] = 1;
C[1][i] = 1;
c_par[i] = i;
BP_C[i].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (V[i].size() == 1) {
int ind = V[i].front(), v = par[ind], p_st = c_par[v], c = col[v];
if (Q[i])
Update(p_st, 3 - c, true);
else
Update(p_st, c, true);
} else if (V[i].size() == 2) {
int ind1 = V[i][0], ind2 = V[i][1], v = par[ind1], u = par[ind2],
p1 = c_par[v], p2 = c_par[u];
if (Q[i] == 0) {
if (p1 != p2) Union(p1, p2, u, v);
} else {
Union2(u, v);
}
}
cout << tot_cost << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 10;
int n, k, l[maxn][2];
int fa[maxn], sz[maxn];
string s;
int get_fa(int x) {
if (x == fa[x]) return x;
return fa[x] = get_fa(fa[x]);
}
int calc(int x) {
int y = x <= k ? x + k : x - k;
x = get_fa(x), y = get_fa(y);
if (x == 0 || y == 0) return sz[x + y];
return min(sz[x], sz[y]);
}
void merge_dis(int x, int y) {
x = get_fa(x);
y = get_fa(y);
if (y == 0) {
swap(x, y);
}
fa[y] = x;
if (x != 0) sz[x] += sz[y];
}
int main() {
scanf("%d%d", &n, &k);
cin >> s;
for (int i = 1; i <= (int)3e5; i++)
fa[i] = i, fa[i + k] = i + k, sz[i + k] = 1;
for (int i = 1, c; i <= k; i++) {
scanf("%d", &c);
for (int j = 0, x; j < c; j++) {
scanf("%d", &x);
if (l[x][0] == 0)
l[x][0] = i;
else
l[x][1] = i;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (l[i][1] == 0) {
int x = l[i][0];
if (x) {
ans -= calc(x);
if (s[i - 1] == '1')
fa[get_fa(x + k)] = 0;
else
fa[get_fa(x)] = 0;
ans += calc(x);
}
} else {
int x = l[i][0], y = l[i][1];
if (s[i - 1] == '1') {
if (get_fa(x) != get_fa(y)) {
ans -= calc(x);
ans -= calc(y);
merge_dis(x, y);
merge_dis(x + k, y + k);
ans += calc(y);
}
} else {
if (get_fa(x + k) != get_fa(y)) {
ans -= calc(x);
ans -= calc(y);
merge_dis(x + k, y);
merge_dis(x, y + k);
ans += calc(x);
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[630000];
int fa[630000];
int val[630000];
vector<int> belong[630000];
int Push(int x) { return x; }
int Unpush(int x) { return m + x; }
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
bool vis[630000];
void merge(int x, int y) {
int u = find(x), v = find(y);
if (u == v) return;
val[v] += val[u];
if (vis[u]) vis[v] = 1;
fa[u] = v;
}
int value(int x) {
if (vis[find(x)]) return 1000000000;
return val[find(x)];
}
int main() {
scanf("%d%d", &n, &m);
scanf("%s", s + 1);
for (int i = 1; i <= m + m; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
val[Push(i)] = 1;
int c;
scanf("%d", &c);
for (int j = 1; j <= c; j++) {
int x;
scanf("%d", &x);
belong[x].push_back(i);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (belong[i].size() == 0) {
} else if (belong[i].size() == 1) {
int v = belong[i][0];
ans -= min(value(Push(v)), value(Unpush(v)));
if (s[i] == '0') {
vis[find(Unpush(v))] = 1;
} else {
vis[find(Push(v))] = 1;
}
ans += min(value(Push(v)), value(Unpush(v)));
} else {
int u = belong[i][0], v = belong[i][1];
if (find(Push(u)) == find(Push(v)) || find(Push(u)) == find(Unpush(v)) ||
find(Push(v)) == find(Unpush(u)) ||
find(Unpush(u)) == find(Unpush(v))) {
} else if (s[i] == '0') {
ans -= min(value(Push(u)), value(Unpush(u)));
ans -= min(value(Push(v)), value(Unpush(v)));
merge(Push(u), Unpush(v));
merge(Push(v), Unpush(u));
ans += min(value(Push(u)), value(Unpush(u)));
} else {
ans -= min(value(Push(u)), value(Unpush(u)));
ans -= min(value(Push(v)), value(Unpush(v)));
merge(Push(u), Push(v));
merge(Unpush(u), Unpush(v));
ans += min(value(Push(u)), value(Unpush(u)));
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const long long INFLL = 4e18L;
const int MOD = 0;
const int N = 3e5 + 3;
const int BLUE = 1, RED = 2;
int n, k;
char init_state[N];
vector<int> has[N];
int color[N];
vector<int> adj_same[N], adj_diff[N];
struct DSU {
vector<int> _leader, _size, _forced, _r, _b;
DSU() {}
DSU(int _n) {
_leader.assign(_n + 1, 0);
for (int i = 1; i <= _n; ++i) _leader[i] = i;
_size.assign(_n + 1, 1);
_forced.assign(_n + 1, 0);
_r.assign(_n + 1, 0);
for (int i = 1; i <= _n; ++i) _r[i] = color[i] == RED;
_b.assign(_n + 1, 0);
for (int i = 1; i <= _n; ++i) _b[i] = color[i] == BLUE;
}
int leader(int x) {
return (_leader[x] == x) ? x : _leader[x] = leader(_leader[x]);
}
void unite(int x, int y) {
x = leader(x);
y = leader(y);
if (x == y) return;
_leader[y] = x;
if (_forced[y]) _forced[x] = _forced[y];
_size[x] += _size[y];
_r[x] += _r[y];
_b[x] += _b[y];
}
int get_ans(int x) {
x = leader(x);
if (_forced[x] == RED) return _r[x];
if (_forced[x] == BLUE) return _b[x];
return min(_r[x], _b[x]);
}
};
void dfs(int i, int c) {
color[i] = c;
for (int j : adj_same[i])
if (!color[j]) {
color[j] = c;
dfs(j, c);
}
for (int j : adj_diff[i])
if (!color[j]) {
color[j] = RED + BLUE - c;
dfs(j, RED + BLUE - c);
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(16);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> init_state[i];
for (int i = 1; i <= k; ++i) {
int nb;
cin >> nb;
while (nb--) {
int j;
cin >> j;
has[j].push_back(i);
}
}
for (int i = 1; i <= n; ++i) {
if ((int)has[i].size() < 2) continue;
int x = has[i].front();
int y = has[i].back();
if (init_state[i] == '0') {
adj_diff[x].push_back(y);
adj_diff[y].push_back(x);
} else if (init_state[i] == '1') {
adj_same[x].push_back(y);
adj_same[y].push_back(x);
}
}
for (int i = 1; i <= k; ++i)
if (!color[i]) dfs(i, RED);
DSU dsu(k);
int ans = 0;
for (int i = 1; i <= n; ++i) {
if ((int)has[i].size() == 1) {
int x = has[i].front();
int lx = dsu.leader(x);
ans -= dsu.get_ans(lx);
if (init_state[i] == '0')
dsu._forced[lx] = color[x];
else if (init_state[i] == '1')
dsu._forced[lx] = RED + BLUE - color[x];
ans += dsu.get_ans(lx);
} else if ((int)has[i].size() == 2) {
int x = has[i].front();
int y = has[i].back();
int lx = dsu.leader(x);
int ly = dsu.leader(y);
if (lx != ly) {
ans -= dsu.get_ans(lx);
ans -= dsu.get_ans(ly);
dsu.unite(lx, ly);
ans += dsu.get_ans(dsu.leader(lx));
}
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 10;
int n, k, l[maxn][2];
int fa[maxn], sz[maxn];
string s;
int get_fa(int x) {
if (x == fa[x]) return x;
return fa[x] = get_fa(fa[x]);
}
int calc(int x) {
int y;
if (x <= k)
y = x + k;
else
y = x - k;
x = get_fa(x), y = get_fa(y);
if (x == 0 || y == 0) return sz[x + y];
return min(sz[x], sz[y]);
}
void merge_dis(int x, int y) {
x = get_fa(x);
y = get_fa(y);
if (y == 0) {
swap(x, y);
}
fa[y] = x;
if (x != 0) sz[x] += sz[y];
}
int main() {
scanf("%d%d", &n, &k);
cin >> s;
for (int i = 1; i <= (int)3e5; i++)
fa[i] = i, fa[i + k] = i + k, sz[i + k] = 1;
for (int i = 1, c; i <= k; i++) {
scanf("%d", &c);
for (int j = 0, x; j < c; j++) {
scanf("%d", &x);
if (l[x][0] == 0)
l[x][0] = i;
else
l[x][1] = i;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (l[i][1] == 0) {
int x = l[i][0];
if (x) {
ans -= calc(x);
if (s[i - 1] == '1')
fa[get_fa(x + k)] = 0;
else
fa[get_fa(x)] = 0;
ans += calc(x);
}
} else {
int x = l[i][0], y = l[i][1];
if (s[i - 1] == '1') {
if (get_fa(x) != get_fa(y)) {
ans -= calc(x);
ans -= calc(y);
merge_dis(x, y);
merge_dis(x + k, y + k);
ans += calc(x);
}
} else {
if (get_fa(x + k) != get_fa(y)) {
ans -= calc(x);
ans -= calc(y);
merge_dis(x + k, y);
merge_dis(x, y + k);
ans += calc(x);
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct perem {
int t = 0, l = 1, p = -1, q = 0;
};
ifstream fin("AAtest.in.txt");
int n, k, m, c, vas, cc = 1000000, kl;
vector<int> vv;
string s;
vector<vector<int>> la;
vector<perem> pr;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k >> s;
la.resize(n, vector<int>(0));
pr.resize(k);
for (int(i) = (0); ((i)) < ((k)); ((i))++) {
cin >> m;
for (int(j) = (0); ((j)) < ((m)); ((j))++) {
cin >> c;
la[c - 1].emplace_back(i);
}
}
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
vas = 0;
if (la[i].size() > 0) {
int a = la[i][0];
bool b1 = s[i] == '1' ? 1 : 0;
while (a != -1) {
b1 ^= pr[a].q;
if (pr[a].p != -1)
a = pr[a].p;
else
break;
}
if (la[i].size() == 1) {
if (!b1) {
vas += pr[a].l;
pr[a].q ^= 1;
}
pr[a].l = cc;
} else {
int b = la[i][1];
while (b != -1) {
b1 ^= pr[b].q;
if (pr[b].p != -1)
b = pr[b].p;
else
break;
}
if (a != b) {
if (!b1) {
if (pr[a].l < pr[b].l) {
vas += pr[a].l;
pr[a].q ^= 1;
} else {
vas += pr[b].l;
pr[b].q ^= 1;
}
kl = abs(pr[a].l - pr[b].l);
} else
kl = min(pr[a].l + pr[b].l, cc);
if (pr[a].t < pr[b].t) swap(a, b);
if (pr[a].q) pr[b].q ^= 1;
if (pr[a].t == pr[b].t) pr[a].t++;
pr[a].l = kl;
pr[b].p = a;
}
}
}
if (i)
vv.emplace_back(vv.back() + vas);
else
vv.emplace_back(vas);
}
for (int i : vv) cout << i << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 900000;
int papa[MAXN], peso[MAXN], custo[MAXN];
int k;
bool obg[MAXN];
int find(int a) {
if (papa[a] == -1) return a;
return papa[a] = find(papa[a]);
}
bool juntos(int a, int b) { return find(a) == find(b); }
void uni(int a, int b) {
a = find(a);
b = find(b);
if (peso[a] < peso[b]) swap(a, b);
peso[a] += peso[b];
papa[b] = a;
custo[a] += custo[b];
obg[a] = obg[a] || obg[b];
}
int con(int a) {
int aa = find(a + k);
a = find(a);
if (obg[a]) return custo[a];
if (obg[aa]) return custo[aa];
return min(custo[a], custo[aa]);
}
char word[MAXN];
vector<int> lam[MAXN];
int main() {
int n;
scanf("%d%d", &n, &k);
scanf("%s", word);
for (int i = 0; i < k; i++) {
int c;
scanf("%d", &c);
for (int j = 0; j < c; j++) {
int num;
scanf("%d", &num);
lam[num - 1].emplace_back(i);
}
}
memset(papa, -1, sizeof papa);
int res = 0;
for (int i = 0; i < k; i++) custo[i] = 1;
for (int i = 0; i < n; i++) {
if (lam[i].size() == 0) {
} else if (lam[i].size() == 1) {
int a = lam[i][0];
res -= con(a);
obg[find(word[i] == '0' ? a : a + k)] = true;
res += con(a);
} else if (lam[i].size() == 2) {
int a = lam[i][0];
int b = lam[i][1];
if (!juntos(a, b) && !juntos(a, b + k)) {
res -= con(a) + con(b);
if (word[i] == '0') {
uni(a, b + k);
uni(b, a + k);
} else {
uni(a, b);
uni(a + k, b + k);
}
res += con(a);
}
}
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 6E5 + 10;
int n, k, l[N][2];
int fa[N], sc[N];
string s;
int find(int x) {
if (x == fa[x]) return x;
return fa[x] = find(fa[x]);
}
int cal(int x) {
int y = x <= k ? x + k : x - k;
int xx = find(x), yy = find(y);
if (xx == 0 || yy == 0) return sc[xx + yy];
return min(sc[xx], sc[yy]);
}
void merge(int x, int y) {
int xx = find(x), yy = find(y);
if (xx == 0)
fa[yy] = xx, sc[xx] += sc[yy];
else
fa[xx] = yy, sc[yy] += sc[xx];
}
int main() {
scanf("%d%d", &n, &k);
cin >> s;
for (int i = 1; i <= k; i++) fa[i] = i, fa[i + k] = i + k, sc[i + k] = 1;
for (int i = 1, c; i <= k; i++) {
scanf("%d", &c);
for (int j = 0, v; j < c; j++) {
scanf("%d", &v);
if (l[v][0])
l[v][1] = i;
else
l[v][0] = i;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (l[i][1] == 0) {
int x = l[i][0];
if (x) {
ans -= cal(x);
if (s[i - 1] == '1')
fa[find(x + k)] = 0;
else
fa[find(x)] = 0;
ans += cal(x);
}
} else {
int x = l[i][0], y = l[i][1];
if (s[i - 1] == '1') {
if (find(x) != find(y)) {
ans -= cal(x);
ans -= cal(y);
merge(x, y);
merge(x + k, y + k);
ans += cal(x);
}
} else {
if (find(x) != find(y + k)) {
ans -= cal(x);
ans -= cal(y);
merge(x, y + k);
merge(x + k, y);
ans += cal(x);
}
}
}
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int MAX_N = 6e5 + 5;
int n, k, a[MAX_N >> 1];
vector<int> op[MAX_N >> 1];
int fa[MAX_N], val[MAX_N];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void unit(int x, int y) {
int fx = find(x), fy = find(y);
if (fx != fy) fa[fy] = fx, val[fx] += val[fy];
}
int get_min(int x) { return min(val[find(x)], val[find(x + k)]); }
int main() {
scanf("%d", &n), scanf("%d", &k);
for (register int i = 1; i <= n; i++) scanf("%1d", &a[i]);
for (register int i = 1; i <= k; i++) {
int x, y;
scanf("%d", &x);
while (x--) scanf("%d", &y), op[y].push_back(i);
}
for (register int i = 1; i <= 2 * k + 1; i++) fa[i] = i, val[i] = (i <= k);
int mx = 2 * k + 1;
val[mx] = inf;
int ans = 0;
for (register int i = 1; i <= n; i++) {
if (op[i].size() == 1) {
int tmp = op[i][0] + k * (a[i] == 0);
ans -= get_min(op[i][0]);
unit(tmp, mx);
ans += get_min(op[i][0]);
} else if (op[i].size() == 2) {
int x = op[i][0], y = op[i][1];
if (a[i] == 0 && find(x) != find(y + k)) {
ans -= (get_min(x) + get_min(y));
unit(x, y + k), unit(x + k, y);
ans += get_min(x);
}
if (a[i] == 1 && find(x) != find(y)) {
ans -= (get_min(x) + get_min(y));
unit(x, y), unit(x + k, y + k);
ans += get_min(x);
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, pre[300005 * 2];
char s[300005];
inline int find(int x) { return x == pre[x] ? x : pre[x] = find(pre[x]); }
int val[300005 * 2], tmp, m;
vector<int> ve[300005];
int ans;
inline int getmin(int x) { return min(val[find(x)], val[find(x + k)]); }
inline void merge(int x, int y) {
int xx = find(x), yy = find(y);
if (xx != yy) {
pre[xx] = yy;
val[yy] += val[xx];
}
}
int main() {
scanf("%d%d%s", &n, &k, s + 1);
for (int i = 1; i <= k; ++i) {
scanf("%d", &m);
while (m--) {
scanf("%d", &tmp);
ve[tmp].push_back(i);
}
}
for (int i = 1; i <= k; ++i) {
pre[i] = i, val[i] = 1;
pre[i + k] = i + k, val[i + k] = 0;
}
pre[2 * k + 1] = 2 * k + 1, val[2 * k + 1] = 0x3f3f3f3f;
ans = 0;
for (int i = 1; i <= n; ++i) {
if (s[i] == '0') {
if (ve[i].size() == 1) {
int id = ve[i][0];
ans -= getmin(id);
merge(id + k, 2 * k + 1);
ans += getmin(id);
} else {
int id1 = ve[i][0], id2 = ve[i][1];
if (find(id1) != find(id2 + k)) {
ans -= getmin(id1) + getmin(id2);
merge(id1, id2 + k), merge(id1 + k, id2);
ans += getmin(id1);
}
}
} else {
if (ve[i].size() == 1) {
int id = ve[i][0];
ans -= getmin(id);
merge(id, 2 * k + 1);
ans += getmin(id);
} else if (ve[i].size() == 2) {
int id1 = ve[i][0], id2 = ve[i][1];
if (find(id1) != find(id2)) {
ans -= getmin(id1) + getmin(id2);
merge(id1, id2), merge(id1 + k, id2 + k);
ans += getmin(id1);
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, kk, s, x, k[N][2];
char ch[N];
int fa[N << 1], val[N << 1];
int find(int u) { return fa[u] == u ? fa[u] : fa[u] = find(fa[u]); }
void uni(int a, int b) {
if (find(a) == find(b)) return;
val[find(b)] += val[find(a)];
fa[find(a)] = find(b);
}
int mix(int a) { return min(val[find(a)], val[find(a + kk)]); };
int main() {
scanf("%d%d%s", &n, &kk, ch + 1);
for (int i = 1; i <= kk; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
k[x][bool(k[x][0])] = i;
}
}
for (int i = 1; i <= kk; i++) val[i] = 1, fa[i] = i, fa[i + kk] = i + kk;
fa[kk + kk + 1] = kk + kk + 1;
val[kk + kk + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (k[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1])) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1]), uni(k[i][0] + kk, k[i][1] + kk);
ans += mix(k[i][1]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0], kk + kk + 1);
ans += val[find(k[i][0] + kk)];
}
} else {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1] + kk)) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1] + kk), uni(k[i][1], k[i][0] + kk);
ans += mix(k[i][0]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0] + kk, kk + kk + 1);
ans += mix(k[i][0]);
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x;
vector<int> vec[300010];
char c[300010];
int fa[300010 << 1], sz[300010 << 1];
int lim[300010 << 1];
int find(int x) {
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
int main() {
scanf("%d%d%s", &n, &k, c + 1);
for (int i = 1; i <= k; i++) {
scanf("%d", &m);
for (int j = 1; j <= m; j++) {
scanf("%d", &x);
vec[x].push_back(i);
}
}
for (int i = 1; i <= k; i++) {
fa[i * 2 - 1] = i * 2 - 1;
sz[i * 2 - 1] = 1;
fa[i * 2] = i * 2;
sz[i * 2] = 0;
lim[i * 2 - 1] = lim[i * 2] = -1;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vec[i].size() == 1) {
int x = vec[i][0];
int f1 = find(x * 2 - 1), f0 = find(x * 2);
int s1 = sz[f1], s0 = sz[f0];
if (lim[f1] != -1)
ans -= lim[f1] ? s1 : s0;
else if (lim[f0] != -1)
ans -= lim[f0] ? s0 : s1;
else
ans -= min(s0, s1);
lim[f1] = (c[i] == '0');
lim[f0] = lim[f1] ^ 1;
ans += lim[f1] ? s1 : s0;
} else if (vec[i].size() == 2) {
int x = vec[i][0], y = vec[i][1];
int fx1 = find(x * 2 - 1), fx0 = find(x * 2);
int sx1 = sz[fx1], sx0 = sz[fx0];
int fy1 = find(y * 2 - 1), fy0 = find(y * 2);
int sy1 = sz[fy1], sy0 = sz[fy0];
if (fx0 != fy0 && fx0 != fy1) {
if (lim[fx1] == -1)
ans -= min(sx0, sx1);
else
ans -= lim[fx1] ? sx1 : sx0;
if (lim[fy1] == -1)
ans -= min(sy0, sy1);
else
ans -= lim[fy1] ? sy1 : sy0;
if (c[i] == '1') {
fa[fx1] = fy1;
fa[fx0] = fy0;
sz[fy1] += sz[fx1];
sz[fy0] += sz[fx0];
if (lim[fx1] != -1) {
lim[fy1] = lim[fx1];
lim[fy0] = lim[fy1] ^ 1;
} else if (lim[fx0] != -1) {
lim[fy0] = lim[fx0];
lim[fy1] = lim[fy0] ^ 1;
}
} else {
fa[fx1] = fy0;
fa[fx0] = fy1;
sz[fy0] += sz[fx1];
sz[fy1] += sz[fx0];
if (lim[fx1] != -1) {
lim[fy0] = lim[fx1];
lim[fy1] = lim[fy0] ^ 1;
} else if (lim[fx0] != -1) {
lim[fy1] = lim[fx0];
lim[fy0] = lim[fy1] ^ 1;
}
}
int f1 = find(x * 2 - 1), f0 = find(x * 2);
int s1 = sz[f1], s0 = sz[f0];
if (lim[f1] == -1)
ans += min(s0, s1);
else
ans += lim[f1] ? s1 : s0;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 7;
int n, k;
string s;
int l[maxn][2], r[maxn], cnt[maxn];
int getroot(int x) { return r[x] == x ? x : r[x] = getroot(r[x]); }
int calc(int x) {
int y = x + k;
x = getroot(x);
y = getroot(y);
if (x == 0 || y == 0) {
return cnt[x + y];
}
return min(cnt[x], cnt[y]);
}
void fmerge(int x, int y) {
x = getroot(x);
y = getroot(y);
if (y == 0) {
swap(x, y);
}
r[y] = x;
if (x != 0) {
cnt[x] += cnt[y];
}
}
int main() {
cin >> n >> k;
cin >> s;
for (int i = 1; i <= k; i++) {
int c;
cin >> c;
for (int j = 0; j < c; j++) {
int x;
cin >> x;
if (l[x][0] == 0)
l[x][0] = i;
else
l[x][1] = i;
}
r[i] = i;
r[i + k] = i + k;
cnt[i + k] = 1;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (l[i][1] == 0) {
int x = l[i][0];
if (x) {
ans -= calc(x);
if (s[i - 1] == '1') {
r[getroot(x + k)] = 0;
} else {
r[getroot(x)] = 0;
}
ans += calc(x);
}
} else {
int x = l[i][0], y = l[i][1];
if (s[i - 1] == '1') {
if (getroot(x) != getroot(y)) {
ans -= calc(x);
ans -= calc(y);
fmerge(x, y);
fmerge(x + k, y + k);
ans += calc(x);
}
} else {
if (getroot(x + k) != getroot(y)) {
ans -= calc(x);
ans -= calc(y);
fmerge(x + k, y);
fmerge(x, y + k);
ans += calc(x);
}
}
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long inf = 1000000;
const int N = 300000;
vector<int> tree(2 * N + 4);
vector<int> ranks(2 * N + 4, 0);
char str[N + 4];
int find(int x) { return x == tree[x] ? x : tree[x] = find(tree[x]); }
void link(int x, int y) {
if (ranks[x] > ranks[y]) {
tree[y] = x;
} else {
tree[x] = y;
if (ranks[x] == ranks[y]) {
ranks[y]++;
}
}
}
long long sum = 0;
vector<vector<int>> graph(N);
vector<int> dists(2 * N);
bool visited[2 * N] = {false};
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin.exceptions(cin.failbit);
int n, k;
cin >> n >> k;
cin >> str;
for (int i = 0; i < k; i++) {
tree[i] = i;
tree[i + N] = i + N;
dists[i] = 1;
dists[i + N] = 0;
}
for (int i = 0; i < k; i++) {
int len;
cin >> len;
for (int a = 0; a < len; a++) {
int e;
cin >> e;
e--;
graph[e].push_back(i);
}
}
for (int i = 0; i < n; i++) {
if (graph[i].empty()) {
cout << sum << "\n";
continue;
}
if (graph[i].size() == 1) {
if (str[i] == '0') {
if (!visited[graph[i][0]]) {
visited[graph[i][0]] = true;
sum++;
visited[graph[i][0] + N] = true;
dists[graph[i][0] + N] = inf;
} else {
int x = find(graph[i][0]);
int y = find(graph[i][0] + N);
sum -= min(dists[x], dists[y]);
dists[y] = inf;
sum += dists[x];
}
} else {
if (!visited[graph[i][0]]) {
visited[graph[i][0]] = true;
visited[graph[i][0] + N] = true;
dists[graph[i][0]] = inf;
} else {
int x = find(graph[i][0]);
int y = find(graph[i][0] + N);
sum -= min(dists[x], dists[y]);
dists[x] = inf;
sum += dists[y];
}
}
} else {
if (graph[i].size() > 2) {
cout << "?????\n";
}
int x1 = find(graph[i][0]);
int x2 = find(graph[i][0] + N);
int y1 = find(graph[i][1]);
int y2 = find(graph[i][1] + N);
if (!visited[graph[i][0]]) {
visited[graph[i][0]] = true;
visited[graph[i][0] + N] = true;
}
if (!visited[graph[i][1]]) {
visited[graph[i][1]] = true;
visited[graph[i][1] + N] = true;
}
sum -= min(dists[x1], dists[x2]);
sum -= min(dists[y1], dists[y2]);
if (str[i] == '0') {
if (x1 == y2) {
sum += min(dists[x1], dists[x2]);
} else if (dists[x1] == inf) {
tree[y2] = x1;
y2 = x1;
} else if (dists[y2] == inf) {
tree[x1] = y2;
x1 = y2;
} else {
tree[y2] = x1;
dists[x1] += dists[y2];
y2 = x1;
}
if (dists[x2] == inf) {
tree[y1] = x2;
y1 = x2;
} else if (dists[y1] == inf) {
tree[x2] = y1;
x2 = y1;
} else if (x2 != y1) {
tree[x2] = y1;
dists[y1] += dists[x2];
x2 = y1;
}
sum += min(dists[x1], dists[x2]);
} else {
if (x1 == y1) {
sum += min(dists[x1], dists[x2]);
} else if (dists[x1] == inf) {
tree[y1] = x1;
y1 = x1;
} else if (dists[y1] == inf) {
tree[x1] = y1;
x1 = y1;
} else {
tree[y1] = x1;
dists[x1] += dists[y1];
y1 = x1;
}
if (dists[x2] == inf) {
tree[y2] = x2;
y2 = x2;
} else if (dists[y2] == inf) {
tree[x2] = y2;
x2 = y2;
} else if (x2 != y2) {
tree[x2] = y2;
dists[y2] += dists[x2];
x2 = y2;
}
sum += min(dists[x1], dists[x2]);
}
}
cout << sum << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long ans = 0;
long long val[600010];
int have[600010][2], fa[600010];
char str[600010];
int n, k;
int find(int x) { return x == fa[x] ? x : (fa[x] = find(fa[x])); }
int other(int u) { return u <= k ? u + k : u - k; }
void update(int u, long long x, long long y) {
ans -= min(val[u], val[other(u)]);
ans += min(x, y);
val[u] = x;
val[other(u)] = y;
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", str + 1);
for (int i = 1; i <= k; i++) {
int c;
scanf("%d", &c);
while (c--) {
int a;
scanf("%d", &a);
if (have[a][0])
have[a][1] = i;
else
have[a][0] = i;
}
val[i] = 0, val[i + k] = 1;
fa[i] = i, fa[i + k] = i + k;
}
for (int i = 1; i <= n; i++) {
if (str[i] == '0') {
int x = find(have[i][0]), y = find(have[i][1]);
if (!y)
update(x, 1e7, val[other(x)]);
else {
long long uy = val[y], vy = val[other(y)];
update(y, 0, 0);
fa[y] = other(x);
fa[other(y)] = x;
update(x, val[x] + vy, val[other(x)] + uy);
}
} else {
int x = find(have[i][0]), y = find(have[i][1]);
if (!x) {
printf("%lld\n", ans);
continue;
}
if (!y)
update(x, val[x], 1e7);
else {
long long uy = val[y], vy = val[other(y)];
update(y, 0, 0);
fa[y] = x;
fa[other(y)] = other(x);
update(x, val[x] + uy, val[other(x)] + vy);
}
}
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int w = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
w = (w << 3) + (w << 1) + ch - 48;
ch = getchar();
}
return w * f;
}
int n, m, f[600010], ans, siz[600010], st[600010], a[300010][2];
inline int find(int x) {
if (f[x] == x)
return f[x];
else
return f[x] = find(f[x]);
}
inline void merge(int x, int y) {
int fx = find(x);
int fy = find(y);
if (fx == fy) return;
f[fx] = fy;
siz[fy] += siz[fx];
return;
}
signed main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) {
char ch;
cin >> ch;
st[i] = ch - '0';
}
for (int i = 1; i <= m; i++) {
int tot = read();
for (int j = 1; j <= tot; j++) {
int x = read();
if (!a[x][0])
a[x][0] = i;
else
a[x][1] = i;
}
}
m++;
for (int i = 0; i <= 2 * m; i++) {
f[i] = i;
if (i <= m) siz[i] = 1;
}
siz[0] = 0x3f3f3f3f;
siz[m] = 0;
for (int i = 1; i <= n; i++) {
int x = a[i][0];
int y = a[i][1];
if (!x) {
cout << ans << endl;
continue;
}
if (st[i] == 0 && find(x) != find(y + m)) {
ans -= min(siz[find(x)], siz[find(x + m)]);
ans -= min(siz[find(y)], siz[find(y + m)]);
merge(x, y + m);
merge(x + m, y);
ans += min(siz[find(x)], siz[find(x + m)]);
cout << ans << endl;
continue;
}
if (st[i] == 1 && find(x) != find(y)) {
ans -= min(siz[find(x)], siz[find(x + m)]);
ans -= min(siz[find(y)], siz[find(y + m)]);
merge(x, y);
merge(x + m, y + m);
ans += min(siz[find(x)], siz[find(x + m)]);
cout << ans << endl;
continue;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, k, s, x, op[N][2];
char ch[N];
int p[N << 1], val[N << 1];
int find(int u) { return p[u] == u ? p[u] : p[u] = find(p[u]); }
void uni(int a, int b) {
if (a == b) return;
val[b] += val[a];
p[a] = b;
}
int main() {
scanf("%d%d%s", &n, &k, ch + 1);
for (int i = 1; i <= k; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
op[x][bool(op[x][0])] = i;
}
}
for (int i = 1; i <= k; i++) val[i] = 1, p[i] = i, p[i + k] = i + k;
p[k + k + 1] = k + k + 1;
val[k + k + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (op[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (op[i][1]) {
if (find(op[i][0]) == find(op[i][1])) goto qwq;
ans -= min(val[find(op[i][1])], val[find(op[i][1] + k)]);
ans -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
uni(find(op[i][0]), find(op[i][1])),
uni(find(op[i][0] + k), find(op[i][1] + k));
ans += min(val[find(op[i][1])], val[find(op[i][1] + k)]);
} else {
ans -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
uni(find(op[i][0]), find(k + k + 1));
ans += val[find(op[i][0] + k)];
}
} else {
if (op[i][1]) {
if (find(op[i][0]) == find(op[i][1] + k)) goto qwq;
ans -= min(val[find(op[i][1])], val[find(op[i][1] + k)]);
ans -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
uni(find(op[i][0]), find(op[i][1] + k)),
uni(find(op[i][1]), find(op[i][0] + k));
ans += min(val[find(op[i][1] + k)], val[find(op[i][0] + k)]);
} else {
ans -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
uni(find(op[i][0] + k), find(k + k + 1));
ans += val[find(op[i][0])];
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 7;
using ll = long long;
string s;
int n, k;
int fa[maxn];
vector<int> st[maxn];
const int inf = 0x3f3f3f3f;
ll sz[maxn];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
void Union(int x, int y) {
x = find(x), y = find(y);
if (x != y) {
fa[y] = x;
sz[x] += sz[y];
}
}
int main() {
for (int i = 0; i < maxn; ++i) fa[i] = i;
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
cin >> s;
for (int i = 0; i < k; ++i) {
sz[i] = 1;
int c;
cin >> c;
for (int j = 0, tmp; j < c; ++j) {
cin >> tmp;
--tmp;
st[tmp].push_back(i);
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
if (st[i].size() == 0)
assert(s[i] == '1');
else if (st[i].size() == 1) {
int a1 = st[i][0];
ans -= min(sz[find(a1)], sz[find(a1 + k)]);
if (s[i] == '1')
sz[find(a1)] += inf;
else
sz[find(a1 + k)] += inf;
ans += min(sz[find(a1)], sz[find(a1 + k)]);
} else {
int u = st[i][0], v = st[i][1];
ans -= min(sz[find(u)], sz[find(u + k)]);
if (find(v) != find(u) && find(u) != find(v + k)) {
ans -= min(sz[find(v)], sz[find(v + k)]);
}
if (s[i] == '0') {
Union(u + k, v);
Union(u, v + k);
} else {
Union(u, v);
Union(u + k, v + k);
}
ans += min(sz[find(u)], sz[find(u + k)]);
if (find(u) != find(v) && find(u) != find(v + k))
ans += min(sz[find(v)], sz[find(v + k)]);
}
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
int dp[maxn][2], fa[maxn * 2], cnt[maxn * 2], n, k;
char buf[maxn];
int Find(int x) { return x == fa[x] ? x : fa[x] = Find(fa[x]); }
int calc(int x) {
int y = (x <= k ? x + k : x - k);
x = Find(x), y = Find(y);
if (x == 0 || y == 0) return cnt[x + y];
return min(cnt[x], cnt[y]);
}
void Unite(int x, int y) {
x = Find(x), y = Find(y);
if (x == 0) swap(x, y);
fa[x] = y;
if (y) cnt[y] += cnt[x];
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", buf + 1);
for (int i = 1; i <= k; ++i) {
int q;
scanf("%d", &q);
while (q--) {
int num;
scanf("%d", &num);
if (dp[num][0])
dp[num][1] = i;
else
dp[num][0] = i;
}
fa[i] = i, fa[i + k] = i + k;
cnt[i + k] = 1;
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (dp[i][1] == 0) {
int x = dp[i][0];
if (x) {
ans -= calc(x);
if (buf[i] == '0')
fa[Find(x)] = 0;
else
fa[Find(x + k)] = 0;
ans += calc(x);
}
} else {
int x = dp[i][0], y = dp[i][1];
if (buf[i] == '1') {
if (Find(x) != Find(y)) {
ans -= calc(x), ans -= calc(y);
Unite(x, y);
Unite(x + k, y + k);
ans += calc(x);
}
} else {
if (Find(x) != Find(y + k)) {
ans -= calc(x);
ans -= calc(y + k);
Unite(x, y + k);
Unite(y, x + k);
ans += calc(x);
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, kk, s, x, k[N][2];
char ch[N];
int fa[N << 1], val[N << 1];
int find(int u) { return fa[u] == u ? fa[u] : fa[u] = find(fa[u]); }
void uni(int a, int b) {
if (find(a) == find(b)) return;
val[find(b)] += val[find(a)];
fa[find(a)] = find(b);
}
int mix(int a) { return min(val[find(a)], val[find(a + kk)]); };
int main() {
scanf("%d%d%s", &n, &kk, ch + 1);
for (int i = 1; i <= kk; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
k[x][bool(k[x][0])] = i;
}
}
for (int i = 1; i <= kk; i++) val[i] = 1, fa[i] = i, fa[i + kk] = i + kk;
fa[kk + kk + 1] = kk + kk + 1;
val[kk + kk + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (k[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1])) goto qwq;
ans -= min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(k[i][0], k[i][1]), uni(k[i][0] + kk, k[i][1] + kk);
ans += min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
} else {
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(k[i][0], kk + kk + 1);
ans += val[find(k[i][0] + kk)];
}
} else {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1] + kk)) goto qwq;
ans -= min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(k[i][0], k[i][1] + kk), uni(k[i][1], k[i][0] + kk);
ans += min(val[find(k[i][1] + kk)], val[find(k[i][0] + kk)]);
} else {
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(k[i][0] + kk, kk + kk + 1);
ans += val[find(k[i][0])];
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9 + 5;
const int N = 600010;
class DSU {
public:
int p[N], cost[N];
int n;
int ans = 0;
DSU(int _n) : n(_n) {
for (int i = 0; i < n; i++) {
cost[2 * i + 1] = 1;
cost[2 * i] = 0;
}
cost[2 * n] = inf;
cost[2 * n + 1] = 0;
for (int i = 0; i < 2 * n + 2; i++) {
p[i] = i;
}
}
int find(int x) { return (x == p[x] ? x : (p[x] = find(p[x]))); }
void unite(int x, int y, bool same) {
assert(0 <= 2 * x && 2 * x + 1 < 2 * n + 2);
assert(0 <= 2 * y && 2 * y + 1 < 2 * n + 2);
int x_true = find(2 * x + 1), y_true = find(2 * y + 1);
int x_false = find(2 * x), y_false = find(2 * y);
if (same) {
if (x_true != y_true) {
assert(x_false != y_false);
ans -= min(cost[x_true], cost[x_false]);
ans -= min(cost[y_true], cost[y_false]);
cost[y_true] += cost[x_true];
cost[y_false] += cost[x_false];
p[x_true] = y_true;
p[x_false] = y_false;
ans += min(cost[y_true], cost[y_false]);
} else {
return;
}
} else {
if (x_true != y_false) {
assert(x_false != y_true);
ans -= min(cost[x_true], cost[x_false]);
ans -= min(cost[y_true], cost[y_false]);
cost[y_true] += cost[x_false];
cost[y_false] += cost[x_true];
p[x_true] = y_false;
p[x_false] = y_true;
ans += min(cost[y_true], cost[y_false]);
} else {
return;
}
}
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<vector<int>> has(n);
for (int i = 0; i < k; i++) {
int size;
cin >> size;
while (size--) {
int x;
cin >> x;
--x;
has[x].push_back(i);
}
}
DSU dsu(k);
int dummy = k;
for (int i = 0; i < n; i++) {
if ((int)has[i].size() == 2) {
dsu.unite(has[i][0], has[i][1], s[i] == '1');
} else if ((int)has[i].size() == 1) {
dsu.unite(has[i].back(), dummy, s[i] == '0');
} else {
assert(s[i] == '1');
}
cout << dsu.ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 10;
int f[maxn], n, k, w[maxn];
vector<int> v[maxn];
int Find(int x) { return f[x] == x ? x : f[x] = Find(f[x]); }
int ask(int x) {
int y = (x <= k) ? x + k : x - k;
x = Find(x);
y = Find(y);
if (x == 0)
return w[y];
else if (y == 0)
return w[x];
else
return min(w[x], w[y]);
}
void Merge(int x, int y) {
x = Find(x), y = Find(y);
if (y == 0) swap(x, y);
f[y] = x;
if (x != 0) w[x] += w[y];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
string s;
cin >> s;
for (long long i = 1; i <= (long long)k; ++i) {
int x;
cin >> x;
for (long long j = 1; j <= (long long)x; ++j) {
int tem;
cin >> tem;
v[tem].push_back(i);
}
f[i] = i;
f[i + k] = i + k;
w[i + k] = 1;
}
int ans = 0;
for (long long i = 1; i <= (long long)n; ++i) {
if (v[i].size() == 1) {
int x = v[i][0];
if (x) {
ans -= ask(x);
if (s[i - 1] == '1')
f[Find(x + k)] = 0;
else
f[Find(x)] = 0;
ans += ask(x);
}
} else {
int x = 0, y = 0;
if (v[i].size() == 2) {
x = v[i][0], y = v[i][1];
}
if (s[i - 1] == '1') {
if (Find(x) != Find(y)) {
ans -= (ask(x) + ask(y));
Merge(x, y);
Merge(x + k, y + k);
ans += ask(x);
}
} else {
if (Find(x + k) != Find(y)) {
ans -= (ask(x) + ask(y));
Merge(x + k, y);
Merge(x, y + k);
ans += ask(x);
}
}
}
cout << ans << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct DS {
int rank, cost, parent;
bool forced;
} ds[4 * 300100];
int ans;
char status[300100];
vector<int> subs[300100];
int neg(int n) { return n + 300100; }
int find(int n) {
if (n == ds[n].parent) return n;
return ds[n].parent = find(ds[n].parent);
}
void join(int n1, int n2) {
int s1 = find(n1), s2 = find(n2);
if (s1 != s2) {
if (ds[s1].rank < ds[s2].rank) swap(s1, s2);
ds[s2].parent = s1;
ds[s1].cost += ds[s2].cost;
ds[s1].rank += ds[s2].rank;
ds[s1].forced |= ds[s2].forced;
}
}
int main() {
int n, k, qtd, v, s1, s2, ns1, ns2, mini;
scanf("%d %d", &n, &k);
getchar();
scanf("%s", status);
for (int i = 0; i < k; i++) {
scanf("%d", &qtd);
for (int j = 0; j < qtd; j++) {
scanf("%d", &v);
subs[v].emplace_back(i);
}
ds[i].rank = 1;
ds[i].cost = 1;
ds[i].parent = i;
ds[i].forced = false;
ds[neg(i)].rank = 1;
ds[neg(i)].cost = 0;
ds[neg(i)].parent = neg(i);
ds[neg(i)].forced = false;
}
for (int i = 1; i <= n; i++) {
if (status[i - 1] == '1') {
if (subs[i].size() == 2) {
s1 = find(subs[i][0]);
s2 = find(subs[i][1]);
ns1 = find(neg(subs[i][0]));
ns2 = find(neg(subs[i][1]));
mini = -1;
if (ds[s1].forced) ans -= ds[s1].cost, mini = 0;
if (ds[ns1].forced) ans -= ds[ns1].cost, mini = 0;
if (mini == -1) {
mini = min(ds[s1].cost, ds[ns1].cost);
ans -= mini;
}
mini = -1;
if (ds[s2].forced and s1 != s2 and ns1 != s2)
ans -= ds[s2].cost, mini = 0;
if (ds[ns2].forced and s1 != ns2 and ns1 != ns2)
ans -= ds[ns2].cost, mini = 0;
if (mini == -1 and s1 != s2 and s1 != ns2 and ns1 != s2 and
ns1 != ns2) {
mini = min(ds[s2].cost, ds[ns2].cost);
ans -= mini;
}
join(s1, s2);
join(ns1, ns2);
s1 = find(subs[i][0]);
s2 = find(subs[i][1]);
ns1 = find(neg(subs[i][0]));
ns2 = find(neg(subs[i][1]));
mini = -1;
if (ds[s1].forced) ans += ds[s1].cost, mini = 0;
if (ds[ns1].forced) ans += ds[ns1].cost, mini = 0;
if (mini == -1) mini = min(ds[s1].cost, ds[ns1].cost);
ans += mini;
} else {
if (subs[i].size() == 1) {
s1 = find(subs[i][0]);
ns1 = find(neg(subs[i][0]));
if (not ds[ns1].forced) {
ans -= min(ds[s1].cost, ds[ns1].cost);
ds[ns1].forced = true;
ans += ds[ns1].cost;
}
}
}
} else {
if (subs[i].size() == 2) {
s1 = find(subs[i][0]);
ns2 = find(neg(subs[i][1]));
ns1 = find(neg(subs[i][0]));
s2 = find(subs[i][1]);
mini = -1;
if (ds[s1].forced) ans -= ds[s1].cost, mini = 0;
if (ds[ns1].forced) ans -= ds[ns1].cost, mini = 0;
if (mini == -1) {
mini = min(ds[s1].cost, ds[ns1].cost);
ans -= mini;
}
mini = -1;
if (ds[s2].forced and s1 != s2 and ns1 != s2)
ans -= ds[s2].cost, mini = 0;
if (ds[ns2].forced and s1 != ns2 and ns1 != ns2)
ans -= ds[ns2].cost, mini = 0;
if (mini == -1 and s1 != s2 and s1 != ns2 and ns1 != s2 and
ns1 != ns2) {
mini = min(ds[s2].cost, ds[ns2].cost);
ans -= mini;
}
join(s1, ns2);
join(ns1, s2);
s1 = find(subs[i][0]);
ns2 = find(neg(subs[i][1]));
ns1 = find(neg(subs[i][0]));
s2 = find(subs[i][1]);
mini = -1;
if (ds[s1].forced) ans += ds[s1].cost, mini = 0;
if (ds[ns1].forced) ans += ds[ns1].cost, mini = 0;
if (mini == -1) mini = min(ds[s1].cost, ds[ns1].cost);
ans += mini;
} else {
if (subs[i].size() == 1) {
s1 = find(subs[i][0]);
ns1 = find(neg(subs[i][0]));
if (not ds[s1].forced) {
ans -= min(ds[s1].cost, ds[ns1].cost);
ds[s1].forced = true;
ans += ds[s1].cost;
}
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long llINF = 2e18, llMOD = 1e9 + 7;
const int INF = 2e9, MOD = 1e9 + 7, P = 179, N = 2e3 + 1, K = 23000, L = 18;
const long double EPS = 1e-6, ldINF = 1e18, PI = acos(-1);
template <typename T>
inline void sort_uniq(vector<T>& v) {
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
}
template <typename T>
inline int sign(T a) {
if (a > 0) {
return 1;
} else if (a == 0) {
return 0;
} else {
return -1;
}
}
template <typename T, typename P>
bool eq(T a, P b) {
return abs(a - b) <= EPS;
}
const char sep[] = " ";
template <typename T, typename P>
istream& operator>>(istream& in, pair<T, P>& p) {
in >> p.first >> p.second;
return in;
}
template <typename T>
void in_seg(istream& in, T* dst_begin, T* dst_end) {
while (dst_begin != dst_end) {
in >> (*dst_begin);
++dst_begin;
}
}
template <typename T>
istream& operator>>(istream& in, vector<T>& v) {
for (T& i : v) {
in >> i;
}
return in;
}
template <typename T, typename P>
ostream& operator<<(ostream& out, pair<T, P> const& p) {
out << p.first << ' ' << p.second;
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> const& v) {
for (T const& i : v) {
out << i << sep;
}
if (!v.empty()) {
out << '\n';
}
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<vector<T>> const& v) {
for (vector<T> const& i : v) {
out << i;
}
return out;
}
void set_precision(ostream& out, int val) {
out.setf(out.fixed, out.floatfield);
out.precision(val);
}
struct edge {
int v, u, x;
};
class Dsu {
int n;
vector<int> p, sz, p_xor, r_st, ans;
int cur_ans = 0;
int dsu_get(int v) {
if (v == p[v]) {
return v;
}
int par = p[v], res = dsu_get(p[v]);
p_xor[v] ^= p_xor[par];
p[v] = res;
return res;
}
int get_vrt_ans(int v) {
v = dsu_get(v);
if (r_st[v] == 0) {
return ans[v];
} else if (r_st[v] == 1) {
return sz[v] - ans[v];
} else {
return min(ans[v], sz[v] - ans[v]);
}
}
void dsu_unite(int v, int u, int x) {
int p_v = dsu_get(v);
int p_u = dsu_get(u);
if (p_v == p_u) {
assert(x == (p_xor[u] ^ p_xor[v]));
return;
}
cur_ans -= get_vrt_ans(p_v);
cur_ans -= get_vrt_ans(p_u);
if (sz[p_v] < sz[p_u]) {
swap(v, u);
swap(p_v, p_u);
}
p_xor[p_u] = p_xor[u] ^ p_xor[v] ^ x;
if (r_st[p_u] != 2) {
if (r_st[p_v] == 2) {
r_st[p_v] = r_st[p_u] ^ p_xor[p_u];
} else {
assert(r_st[p_v] == (r_st[p_u] ^ p_xor[p_u]));
}
}
if (p_xor[p_u]) {
ans[p_v] += sz[p_u] - ans[p_u];
} else {
ans[p_v] += ans[p_u];
}
p[p_u] = p_v;
sz[p_v] += sz[p_u];
cur_ans += get_vrt_ans(p_v);
}
public:
Dsu(vector<int> r_st)
: n(r_st.size()), p(n), sz(n, 1), p_xor(n), r_st(r_st), ans(n) {
for (int i = 0; i < n; i++) {
p[i] = i;
}
}
int get_ans() { return cur_ans; }
void set_rst(int v, int st) {
int p_v = dsu_get(v);
if (r_st[p_v] != 2) {
assert(r_st[p_v] == (st ^ p_xor[v]));
return;
}
cur_ans -= get_vrt_ans(p_v);
r_st[p_v] = st ^ p_xor[v];
cur_ans += get_vrt_ans(p_v);
}
void unite(int v, int u, int x) { dsu_unite(v, u, x); }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
string s;
vector<vector<int>> v_mask(n);
vector<int> mask_st(k, 2);
vector<vector<edge>> e(n);
cin >> s;
for (int i = 0, c; i < k; i++) {
cin >> c;
for (int j = 0, x; j < c; j++) {
cin >> x;
v_mask[x - 1].push_back(i);
}
}
int ban_bit = n;
for (int i = 0; i < n; i++) {
if (v_mask[i].size() == 1) {
if (s[i] == '0') {
mask_st[v_mask[i][0]] = 1;
} else {
mask_st[v_mask[i][0]] = 0;
}
} else if (v_mask[i].size() == 2) {
int v = v_mask[i][0];
int u = v_mask[i][1];
if (s[i] == '0') {
e[i].push_back({v, u, 1});
} else {
e[i].push_back({v, u, 0});
}
} else {
assert(v_mask[i].size() == 0);
}
}
Dsu dsu(vector<int>(k, 2));
for (int i = 0; i < n; i++) {
for (auto [v, u, x] : e[i]) {
dsu.unite(v, u, x);
}
if (v_mask[i].size() == 1) {
dsu.set_rst(v_mask[i][0], mask_st[v_mask[i][0]]);
}
cout << dsu.get_ans() << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MX = 1e6, INF = 1e9 + 10;
vector<long long> v[MX];
long long par[MX], s0[MX], s1[MX], col[MX], ans = 0;
pair<long long, long long> GETPAR(long long v) {
if (par[v] == v) return {v, 0};
pair<long long, long long> ans = GETPAR(par[v]);
return {par[v] = ans.first, col[v] ^= ans.second};
}
void MERGE(long long a, long long b, long long stt) {
pair<long long, long long> u = GETPAR(a), v = GETPAR(b);
if (u.first == v.first) return;
ans -= min(s0[u.first], s1[u.first]) + min(s0[v.first], s1[v.first]);
if (stt ^ u.second ^ v.second) {
swap(s0[v.first], s1[v.first]);
col[v.first] = 1;
}
par[v.first] = u.first;
s0[u.first] += s0[v.first];
s1[u.first] += s1[v.first];
ans += min(s0[u.first], s1[u.first]);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, k;
string s;
cin >> n >> k >> s;
for (long long i = 0; i < k; i++) {
s0[i] = 1;
par[i] = i;
long long l;
cin >> l;
while (l--) {
long long x;
cin >> x;
x--;
v[x].push_back(i);
}
}
for (long long i = 0; i < n; i++) {
if (v[i].size() == 1) {
par[i + k] = i + k;
s0[i + k] = INF;
MERGE(v[i][0], i + k, s[i] == '0');
}
if (v[i].size() == 2) MERGE(v[i][0], v[i][1], s[i] == '0');
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int test = 0;
const int MAXN = 300009;
const long long MOD = 119 << 23 | 1;
class {
public:
vector<int> V[MAXN];
int fa[MAXN * 2], cnt[MAXN * 2];
int n, m;
int findfa(int x) {
if (fa[x] == x) return x;
return fa[x] = findfa(fa[x]);
}
void merge(int x, int y) {
x = findfa(x);
y = findfa(y);
if (x == y) return;
if (x > y) swap(x, y);
fa[y] = x;
cnt[x] += cnt[y];
}
void solve() {
cin >> n >> m;
string s;
cin >> s;
for (int i = 1; i <= m; ++i) {
int c;
cin >> c;
for (int j = 0; j < c; ++j) {
int v;
cin >> v;
V[v].push_back(i);
}
fa[i] = i;
fa[i + m] = i + m;
cnt[i + m] = 1;
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
bool on = s[i - 1] == '1';
if (V[i].size() == 1) {
int p = V[i][0];
if (on) {
ans -= cost(p);
merge(p + m, 0);
ans += cost(p);
} else {
ans -= cost(p);
merge(p, 0);
ans += cost(p);
}
} else if (V[i].size() == 2) {
int p0 = V[i][0], p1 = V[i][1];
if (on) {
if (findfa(p0) != findfa(p1)) {
ans -= cost(p0);
ans -= cost(p1);
merge(p0, p1);
merge(p0 + m, p1 + m);
ans += cost(p0);
} else {
;
}
} else {
if (findfa(p0) != findfa(p1 + m)) {
ans -= cost(p0);
ans -= cost(p1);
merge(p0, p1 + m);
merge(p0 + m, p1);
ans += cost(p0);
} else {
;
}
}
}
cout << ans << '\n';
}
}
int cost(int x) {
int y;
if (x <= m) {
y = m + x;
} else {
y = x - m;
}
x = findfa(x);
y = findfa(y);
if (x == 0)
return cnt[y];
else if (y == 0)
return cnt[x];
return min(cnt[x], cnt[y]);
}
} NSPACE;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
NSPACE.solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-10;
const int MOD = 998857459;
const int INF = 0x3f3f3f3f;
const int maxn = 3e5 + 10;
const int maxm = 5e6 + 10;
int n, k, op[maxn][2], p[maxn << 2];
long long val[maxn << 2];
char str[maxn];
int find(int first) {
return p[first] == first ? p[first] : p[first] = find(p[first]);
}
void merge(int first, int second) {
if (first == second) return;
val[second] += val[first];
p[first] = second;
}
int main() {
cin >> n >> k;
scanf("%s", str + 1);
for (int i = 1, sz, a; i <= k; ++i) {
scanf("%d", &sz);
while (sz--) {
scanf("%d", &a);
if (!op[a][0])
op[a][0] = i;
else
op[a][1] = i;
}
}
for (int i = 1; i <= k; ++i) p[i] = i, p[i + k] = i + k, val[i] = 1;
p[k * 2 + 1] = k * 2 + 1;
val[k * 2 + 1] = INF;
int now = 0;
for (int i = 1; i <= n; ++i) {
if (!op[i][0]) goto out;
if (str[i] == '1') {
if (op[i][1]) {
if (find(op[i][0]) == find(op[i][1])) goto out;
now -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
now -= min(val[find(op[i][1])], val[find(op[i][1] + k)]);
merge(find(op[i][0]), find(op[i][1]));
merge(find(op[i][0] + k), find(op[i][1] + k));
now += min(val[find(op[i][1])], val[find(op[i][1] + k)]);
} else {
now -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
merge(find(op[i][0]), find(k * 2 + 1));
now += val[find(op[i][0] + k)];
}
} else {
if (op[i][1]) {
if (find(op[i][0]) == find(op[i][1] + k)) goto out;
now -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
now -= min(val[find(op[i][1])], val[find(op[i][1] + k)]);
merge(find(op[i][0]), find(op[i][1] + k));
merge(find(op[i][1]), find(op[i][0] + k));
now += min(val[find(op[i][1] + k)], val[find(op[i][0] + k)]);
} else {
now -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
merge(find(op[i][0] + k), find(k * 2 + 1));
now += val[find(op[i][0])];
}
}
out:
printf("%d\n", now);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9 + 7;
class DSU {
private:
vector<int> comp, siz;
vector<int> tp;
vector<int> onc, offc;
public:
DSU(int n) : comp(n), siz(n, 1), tp(n, 0), onc(n, 0), offc(n, 1) {
for (int i = 0; i < n; ++i) comp[i] = i;
offc[n - 1] = INF;
}
pair<int, int> getc(int i) {
if (comp[i] != i) {
auto sub = getc(comp[i]);
comp[i] = sub.first;
tp[i] ^= sub.second;
}
return {comp[i], tp[i]};
}
int join(int a, int b, int t) {
int at, bt;
tie(a, at) = getc(a);
tie(b, bt) = getc(b);
t ^= at ^ bt;
if (a == b) return 0;
int add = -(min(onc[a], offc[a]) + min(onc[b], offc[b]));
siz[a] += siz[b];
comp[b] = a;
tp[b] = t;
if (tp[b]) {
onc[a] += offc[b];
offc[a] += onc[b];
} else {
onc[a] += onc[b];
offc[a] += offc[b];
}
add += min(onc[a], offc[a]);
return add;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<pair<int, int>> lamps(n, {k, k});
string str;
cin >> str;
for (int j = 0; j < k; ++j) {
int c;
cin >> c;
for (int i = 0; i < c; ++i) {
int x;
cin >> x;
--x;
if (lamps[x].first == k)
lamps[x].first = j;
else if (lamps[x].second == k)
lamps[x].second = j;
}
}
DSU dsu(k + 1);
int res = 0;
for (int i = 0; i < n; ++i) {
res += dsu.join(lamps[i].first, lamps[i].second, str[i] == '0');
cout << res << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, kk, s, x, k[N][2];
char ch[N];
int fa[N << 1], val[N << 1];
int find(int u) { return fa[u] == u ? fa[u] : fa[u] = find(fa[u]); }
void uni(int a, int b) {
if (find(a) == find(b)) return;
val[find(b)] += val[find(a)];
fa[find(a)] = find(b);
}
int mix(int a) { return min(val[find(a)], val[find(a + kk)]); };
int main() {
scanf("%d%d%s", &n, &kk, ch + 1);
for (int i = 1; i <= kk; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
k[x][bool(k[x][0])] = i;
}
}
for (int i = 1; i <= kk; i++) val[i] = 1, fa[i] = i, fa[i + kk] = i + kk;
fa[kk + kk + 1] = kk + kk + 1;
val[kk + kk + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (k[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1])) goto qwq;
ans -= min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(find(k[i][0]), find(k[i][1])),
uni(find(k[i][0] + kk), find(k[i][1] + kk));
ans += min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
} else {
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(find(k[i][0]), find(kk + kk + 1));
ans += val[find(k[i][0] + kk)];
}
} else {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1] + kk)) goto qwq;
ans -= min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(find(k[i][0]), find(k[i][1] + kk)),
uni(find(k[i][1]), find(k[i][0] + kk));
ans += min(val[find(k[i][1] + kk)], val[find(k[i][0] + kk)]);
} else {
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(find(k[i][0] + kk), find(kk + kk + 1));
ans += val[find(k[i][0])];
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, const T& b) {
return a > b ? a = b, true : false;
}
template <class T>
bool umax(T& a, const T& b) {
return a < b ? a = b, true : false;
}
template <long long sz>
using tut = array<long long, sz>;
const long long N = 3e5 + 5;
const long long mod = 1e9 + 7;
const long long inf = 1e18;
const long double Pi = acos(-1);
const long long MX = 2e16;
long long n, m, k, t, q, ans, res, a[N];
long long in[N][2], cc[N], cnt[N][2];
long long par[N], sz[N];
vector<long long> edges[N];
string s;
void dfs(long long u) {
cnt[u][cc[u]]++;
for (auto x : edges[u]) {
if (in[x][1] == -1) continue;
long long to = in[x][0] + in[x][1] - u;
if (~cc[to]) continue;
cc[to] = cc[u] ^ (s[x] == '0');
dfs(to);
}
}
long long f(long long x) { return (par[x] == x ? x : par[x] = f(par[x])); }
void add(long long a, long long s0, long long s1) {
a = f(a);
res -= min(cnt[a][0], cnt[a][1]);
cnt[a][0] += s0, cnt[a][1] += s1;
res += min(cnt[a][0], cnt[a][1]);
}
void merge(long long a, long long b) {
a = f(a), b = f(b);
if (a == b) return;
if (sz[b] > sz[a]) swap(a, b);
add(a, cnt[b][0], cnt[b][1]);
add(b, -cnt[b][0], -cnt[b][1]);
sz[a] += sz[b], par[b] = a;
}
void solve(long long t_case) {
cin >> n >> k >> s;
s = '$' + s;
memset(in, -1, sizeof in), memset(cc, -1, sizeof cc);
for (long long i = 0; i < k; i++) {
sz[i] = 1, par[i] = i;
long long c;
cin >> c;
for (long long j = 0; j < c; j++) {
long long x;
cin >> x, edges[i].push_back(x);
if (~in[x][0])
in[x][1] = i;
else
in[x][0] = i;
}
}
for (long long i = 0; i < k; i++) {
if (~cc[i]) continue;
cc[i] = 0, dfs(i);
}
for (long long i = 1; i <= n; i++) {
long long c0 = in[i][0], c1 = in[i][1];
if (~c0 && c1 == -1) {
if (s[i] == '0') {
if (cc[c0])
add(c0, mod, 0);
else
add(c0, 0, mod);
} else {
if (cc[c0])
add(c0, 0, mod);
else
add(c0, mod, 0);
}
}
if (~c0 && ~c1) {
merge(c0, c1);
}
cout << res << "\n";
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (0) {
long long t;
cin >> t;
for (long long t_case = 1; t_case <= t; t_case++) solve(t_case);
} else
solve(1);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.