Submission #676017

#	Time	Username	Problem	Language	Result	Execution time	Memory
676017		MilosMilutinovic	Digital Circuit (IOI22_circuit)	C++17	100 / 100	1283 ms	366408 KiB

circuit

#include "circuit.h"

#include <bits/stdc++.h>

using namespace std;

const int MOD = 1000002022;

int ckadd(int a, int b) {
	return a + b >= MOD ? a + b - MOD : a + b;
}
int ckmul(int a, int b) {
	return a * 1LL * b % MOD;
}
int ckpower(int a, int n) {
	int res = 1;
	while (n) {
		if (n & 1)
			res = ckmul(res, a);
		a = ckmul(a, a);
		n >>= 1;
	}
	return res;
}
int ckdiv(int a, int b) {
	return ckmul(a, ckpower(b, MOD - 2));
}

const int N = (int)2e5 + 6;
int n, m;
int a[N];
int par[N];
int deg[N];
int ANS[N];
bool vis[N];
int prod[N];
vector<int> g[N];

void dfsProd(int v) {
	prod[v] = deg[v];
	for (int u : g[v]) {
		if (u < n) {
			dfsProd(u);
			prod[v] = ckmul(prod[v], prod[u]);
		} else prod[u] = 1;
	}
}

void dfsSolve(int v, int x) {
	if (v >= n) {
		ANS[v] = x;
		return;
	}
	vector<int> L;
	vector<int> R;
	L.push_back(1);
	for (int i = 0; i < (int) g[v].size(); i++) {
		L.push_back(ckmul(L.back(), prod[g[v][i]]));
	}
	R.push_back(1);
	for (int i = (int) g[v].size() - 1; i >= 0; i--) {
		R.push_back(ckmul(R.back(), prod[g[v][i]]));
	}
	reverse(R.begin(), R.end());
	for (int i = 0; i < (int) g[v].size(); i++) {
		dfsSolve(g[v][i], ckmul(x, ckmul(L[i], R[i + 1])));
	}
}

const int S = (1 << 24);
struct Node {
	int l, r;
	int s0, s1;
	bool lzy;

	Node() : l(-1), r(-1), s0(0), s1(0), lzy(0) {}
	Node(int _l, int _r) : l(_l), r(_r), s0(0), s1(0), lzy(0) {}
};
Node tree[S];

void build(int p, int l, int r) {
	tree[p] = Node(l, r);
	if (l == r) {
		if (a[l] == 0) tree[p].s0 = ANS[l];
		else tree[p].s1 = ANS[l];
		return;
	}
	build(p * 2, l, (l + r) / 2);
	build(p * 2 + 1, (l + r) / 2 + 1, r);
	tree[p].s0 = ckadd(tree[p * 2].s0, tree[p * 2 + 1].s0);
	tree[p].s1 = ckadd(tree[p * 2].s1, tree[p * 2 + 1].s1);
}
void propagate(int p) {
	if (!tree[p].lzy || tree[p].l == tree[p].r) return;
	swap(tree[p * 2].s0, tree[p * 2].s1);
	swap(tree[p * 2 + 1].s0, tree[p * 2 + 1].s1);
	tree[p * 2].lzy = !tree[p * 2].lzy;
	tree[p * 2 + 1].lzy = !tree[p * 2 + 1].lzy;
	tree[p].lzy = false;
}
void flipSeg(int p, int l, int r) {
	if (tree[p].l > tree[p].r || tree[p].l > r || tree[p].r < l) return;
	if (l <= tree[p].l && tree[p].r <= r) {
		swap(tree[p].s0, tree[p].s1);
		tree[p].lzy = !tree[p].lzy;
		propagate(p);
		return;
	}
	propagate(p);
	flipSeg(p * 2, l, r);
	flipSeg(p * 2 + 1, l, r);
	tree[p].s0 = ckadd(tree[p * 2].s0, tree[p * 2 + 1].s0);
	tree[p].s1 = ckadd(tree[p * 2].s1, tree[p * 2 + 1].s1);
}

void init(int N, int M, std::vector<int> P, std::vector<int> A) {
	n = N; m = M;
	for (int i = n; i < n + m; i++) a[i] = A[i - n];
	for (int i = 0; i < n + m; i++) par[i] = P[i];
	for (int i = 1; i < n + m; i++) {
		g[par[i]].push_back(i);
		deg[par[i]]++;
	}
	dfsProd(0);
	dfsSolve(0, 1);
	build(1, n, n + m - 1);
}

int count_ways(int L, int R) {
	flipSeg(1, L, R);
	return tree[1].s1;
}

/*
3 4 3
-1 0 1 2 1 1 0
1 0 1 0
3 4
4 5
3 6

*/

• Subtask 1: 2 / 2
• Subtask 2: 7 / 7
• Subtask 3: 9 / 9
• Subtask 4: 4 / 4
• Subtask 5: 12 / 12
• Subtask 6: 27 / 27
• Subtask 7: 28 / 28
• Subtask 8: 11 / 11