제출 #1178230

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
1178230		Nonoze	디지털 회로 (IOI22_circuit)	C++17	34 / 100	3085 ms	12748 KiB

circuit

#include "circuit.h"

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int MOD= 1000002022;


struct node
{
	node* left, *right;
	int allume, eteint, lazy;
	void update()
	{
		int comp=0;
		comp+=(left->eteint*right->allume)%MOD;
		comp+=(left->allume*right->eteint)%MOD;
		comp%=MOD;
		allume=comp+(left->allume*right->allume*2);
		eteint=comp+(left->eteint*right->eteint*2);
		allume%=MOD, eteint%=MOD;
	}
};

/*int query(node* root, int left, int right, int qLeft, int qRight)
{
	if (left>qRight || right<qLeft) return 0;
	if (left>=qLeft && right<=qRight) return root->sum;

	int mid=(left+right)/2;
	return query(root->left, left, mid, qLeft, qRight)+query(root->right, mid+1, right, qLeft, qRight);
}*/

void propagation(node *root, int left, int right) {
	if (!root->lazy) return;
	swap(root->allume, root->eteint);
	if (left!=right) {
		root->left->lazy^=1, root->right->lazy^=1;
	}
	root->lazy=0;
}

void update(node* root, int left, int right, int qLeft, int qRight)
{
	propagation(root, left, right);
	if (left>qRight || right<qLeft) return;
	if (left>=qLeft && right<=qRight)
	{
		root->lazy^=1;
		propagation(root, left, right);
		return;
	}

	int mid=(left+right)/2;
	update(root->left, left, mid, qLeft, qRight);
	update(root->right, mid+1, right, qLeft, qRight);
	root->update();
}

void build(node* root, int left, int right, const vector<signed> &v)
{
	if (left==right)
	{
		root->allume=v[left];
		root->eteint=v[left]^1;
		return;
	}

	root->left=new node{NULL, NULL, 0, 0, 0};
	root->right=new node{NULL, NULL, 0, 0, 0};

	int mid=(left+right)/2;
	build(root->left, left, mid, v);
	build(root->right, mid+1, right, v);
	root->update();
}

void destroy(node* root)
{
	if (root->left) destroy(root->left);
	if (root->right) destroy(root->right);
	delete root;
}

vector<signed> a;
vector<int> adj[100005];
int n, m;

pair<int, int> dfs(int s) {
	if (s>=n) {
		return {a[s-n], a[s-n]^1};
	}
	vector<int> dp(adj[s].size()+1, 0);
	dp[0]=1;
	for (auto u: adj[s]) {
		auto act=dfs(u);
		for (int i=dp.size()-1; i>=0; i--) {
			dp[i]=(dp[i]*act.second)%MOD;
			if (i>0) {
				dp[i]+=(dp[i-1]*act.first)%MOD;
			}
			dp[i]%=MOD;
		}
	}
	pair<int, int> ans={0, 0};
	for (int i=1; i<(int)dp.size()-1; i++) {
		ans.first+=(dp[i]*i)%MOD;
		ans.second+=(dp[i]*(dp.size()-i-1));
		ans.first%=MOD, ans.second%=MOD;
	}
	ans.first+=dp[dp.size()-1]*(dp.size()-1);
	ans.second+=dp[0]*(dp.size()-1);
	return {ans.first%MOD, ans.second%MOD};
}
bool subtask5=false;
node *root=new node{NULL, NULL, 0, 0, 0};
#undef int
void init(int N, int M, vector<int> p, vector<int> aa) {
	
	subtask5=1;
	a=aa;
	n=N, m=M; 
	for (int i=1; i<n+m; i++) {
		adj[p[i]].push_back(i);
		if (p[i]!=(i-1)/2) subtask5=0;
	}
	if (m!=n+1 || !subtask5) {
		subtask5=0;
		return;
	}
	int power=1;
	while (power<m) power*=2;
	if (power!=m) {
		subtask5=0;
		return;
	}
	build(root, 0, m-1, a);
}

int count_ways(int L, int R) {
	#define int long long
	if (subtask5) {
		update(root, 0, m-1, L-n, R-n);
		return root->allume;
	}
	for (int i=L; i<=R; i++) {
		a[i-n]^=1;
	}
	return dfs(0).first;
}

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