Problem:
双子 (Twins)
square1001君とE869120君は双子です。
このうち先に生まれた方を出力して下さい。
入力
入力は与えられない。
出力
正解の文字列を一行に出力せよ。
ただし、最後には改行を入れること。
出力例1
square1001

Submitted solutions:

code_snippet: #include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
typedef pair<int,int>P;

vector<int>E[200000];
int sz[200000];
int vid[200000];
int par[200000];
int dep[200000];

int belong[200000];
int cid[200000];
int col[200000];

struct Segtree{
	int N;
	vector<int>dat;
	Segtree(){}
	Segtree(int n):N(n){dat=vector<int>(2*n);}
	void update(int k,int x){
		//~ k+=N;
		//~ dat[k]+=x;
		//~ while(k>1){
			//~ k>>=1;
			//~ dat[k]=dat[k*2]+dat[k*2+1];
		//~ }
		dat[k]+=x;
	}
	int query(int l,int r){
		int res=0;
		//~ for(l+=N,r+=N;l<r;l>>=1,r>>=1){
			//~ if(l&1)res+=dat[l++];
			//~ if(r&1)res+=dat[--r];
		//~ }
		for(int i=l;i<r;i++)res+=dat[i];
		return res;
	}
};

struct Chain;

struct Chain{
	int id;
	vector<int>nodes;
	set<int>black;
	Segtree tree;
	int cur;

	bool init(){
		if(nodes.empty())return false;
		black.insert(-1);
		black.insert(nodes.size());
		id=nodes[0];
		cur=0;
		tree=Segtree(nodes.size());
		return true;
	}
	void update();
	int get(int v){
		assert(!black.count(v));
		auto l=black.lower_bound(v);
		auto r=l;l--;
		int L=*l,R=*r;
		return R-L-1+tree.query(L+1,R);
	}
};

Chain chain[200000];

void Chain::update(){
	if(par[id]==-1)return;
	int r=*++black.begin();
	auto&t=chain[belong[par[id]]].tree;
	t.update(cid[par[id]],-cur);
	int sum=tree.query(0,r)+r;
	cur=sum;
	t.update(cid[par[id]],cur);
}

int node_num;

void dfs(int v,int p,int d){
	sz[v]=1;
	par[v]=p;
	dep[v]=d;
	for(int u:E[v]){
		if(u==p)continue;
		dfs(u,v,d+1);
		sz[v]+=sz[u];
	}
}

void hld(int v,int k){
	vid[v]=node_num++;
	belong[v]=k;
	cid[v]=chain[k].nodes.size();
	chain[k].nodes.push_back(v);
	int Max=0,id=-1;
	for(int u:E[v]){
		if(u==par[v])continue;
		if(Max<sz[u])Max=sz[u],id=u;
	}
	if(id==-1)return;
	hld(id,k);
	for(int u:E[v]){
		if(u==par[v]||u==id)continue;
		hld(u,u);
	}
}

int find_par(int v){
	int b=belong[v],c=cid[v];
	auto it=chain[b].black.lower_bound(c);it--;
	if(it!=chain[b].black.begin())return v;
	else if(par[b]==-1||col[par[b]]==1)return v;
	return find_par(par[b]);
}

void update_par(int v){
	int b=belong[v];
	chain[b].update();
	if(par[b]!=-1)update_par(par[b]);
}

int main(){
	int n,q;cin>>n>>q;
	assert(1<=n&&n<=100000);
	assert(1<=q&&q<=100000);
	rep(i,n-1){
		int a,b;scanf("%d%d",&a,&b);a--;b--;
		assert(0<=a&&a<n);
		assert(0<=b&&b<n);
		assert(a!=b);
		E[a].push_back(b);
		E[b].push_back(a);
	}
	dfs(0,-1,0);
	hld(0,0);
	vector<P>vs;
	rep(i,n){
		if(!chain[i].init())continue;
		vs.push_back(P(dep[i],i));
	}
	sort(vs.begin(),vs.end());
	for(int i=vs.size()-1;i>=0;i--){
		chain[vs[i].second].update();
	}
	//~ rep(i,n){
		//~ cout<<"par="<<find_par(i)<<endl;
		//~ int x=find_par(i);
		//~ cout<<chain[belong[x]].get(cid[x])<<endl;
	//~ }
	rep(i,q){
		int ty,v;scanf("%d%d",&ty,&v);v--;
		if(ty==1){
			int b=belong[v],c=cid[v];
			if(col[v])chain[b].black.erase(c);
			col[v]^=1;
			if(col[v])chain[b].black.insert(c);
			update_par(belong[v]);
		}
		else{
			int x=find_par(v);
			printf("%d\n",chain[belong[x]].get(cid[x]));
		}
	}
}
accuracy: 1
time_ms: 860
memory_kb: 50624
final_rank: 3

code_snippet: #include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
typedef pair<int,int>P;

vector<int>E[200000];
int sz[200000];
int vid[200000];
int par[200000];
int dep[200000];

int belong[200000];
int cid[200000];
int col[200000];

struct Segtree{
	int N;
	vector<int>dat;
	Segtree(){}
	Segtree(int n):N(n){dat=vector<int>(2*n);}
	void update(int k,int x){
		//~ k+=N;
		//~ dat[k]+=x;
		//~ while(k>1){
			//~ k>>=1;
			//~ dat[k]=dat[k*2]+dat[k*2+1];
		//~ }
		dat[k]+=x;
	}
	int query(int l,int r){
		int res=0;
		//~ for(l+=N,r+=N;l<r;l>>=1,r>>=1){
			//~ if(l&1)res+=dat[l++];
			//~ if(r&1)res+=dat[--r];
		//~ }
		for(int i=l;i<r;i++)res+=dat[i];
		return res;
	}
};

struct Chain;

struct Chain{
	int id;
	vector<int>nodes;
	set<int>black;
	Segtree tree;
	int cur;

	bool init(){
		if(nodes.empty())return false;
		black.insert(-1);
		black.insert(nodes.size());
		id=nodes[0];
		cur=0;
		tree=Segtree(nodes.size());
		return true;
	}
	void update();
	int get(int v){
		assert(!black.count(v));
		auto l=black.lower_bound(v);
		auto r=l;l--;
		int L=*l,R=*r;
		return R-L-1+tree.query(L+1,R);
	}
};

Chain chain[200000];

void Chain::update(){
	if(par[id]==-1)return;
	int r=*++black.begin();
	auto&t=chain[belong[par[id]]].tree;
	t.update(cid[par[id]],-cur);
	int sum=tree.query(0,r)+r;
	cur=sum;
	t.update(cid[par[id]],cur);
}

int node_num;

void dfs(int v,int p,int d){
	sz[v]=1;
	par[v]=p;
	dep[v]=d;
	for(int u:E[v]){
		if(u==p)continue;
		dfs(u,v,d+1);
		sz[v]+=sz[u];
	}
}

void hld(int v,int k){
	vid[v]=node_num++;
	belong[v]=k;
	cid[v]=chain[k].nodes.size();
	chain[k].nodes.push_back(v);
	int Max=0,id=-1;
	for(int u:E[v]){
		if(u==par[v])continue;
		if(Max<sz[u])Max=sz[u],id=u;
	}
	if(id==-1)return;
	hld(id,k);
	for(int u:E[v]){
		if(u==par[v]||u==id)continue;
		hld(u,u);
	}
}

int find_par(int v){
	//~ int b=belong[v],c=cid[v];
	//~ auto it=chain[b].black.lower_bound(c);it--;
	//~ if(it!=chain[b].black.begin())return v;
	//~ else if(par[b]==-1||col[par[b]]==1)return v;
	//~ return find_par(par[b]);
	if(par[v]==-1||col[par[v]]==1)return v;
	return find_par(par[v]);
}

void update_par(int v){
	int b=belong[v];
	chain[b].update();
	if(par[b]!=-1)update_par(par[b]);
}

int main(){
	int n,q;cin>>n>>q;
	assert(1<=n&&n<=100000);
	assert(1<=q&&q<=100000);
	rep(i,n-1){
		int a,b;scanf("%d%d",&a,&b);a--;b--;
		assert(0<=a&&a<n);
		assert(0<=b&&b<n);
		assert(a!=b);
		E[a].push_back(b);
		E[b].push_back(a);
	}
	dfs(0,-1,0);
	hld(0,0);
	vector<P>vs;
	rep(i,n){
		if(!chain[i].init())continue;
		vs.push_back(P(dep[i],i));
	}
	sort(vs.begin(),vs.end());
	for(int i=vs.size()-1;i>=0;i--){
		chain[vs[i].second].update();
	}
	rep(i,q){
		int ty,v;scanf("%d%d",&ty,&v);v--;
		if(ty==1){
			int b=belong[v],c=cid[v];
			if(col[v])chain[b].black.erase(c);
			col[v]^=1;
			if(col[v])chain[b].black.insert(c);
			update_par(belong[v]);
		}
		else{
			int x=find_par(v);
			printf("%d\n",chain[belong[x]].get(cid[x]));
		}
	}
}
accuracy: 1
time_ms: 110
memory_kb: 47128
final_rank: 2

code_snippet: #include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
typedef pair<int,int>P;

vector<int>E[200000];
int sz[200000];
int vid[200000];
int par[200000];
int dep[200000];

int belong[200000];
int cid[200000];
int col[200000];

struct Segtree{
	int N;
	vector<int>dat;
	Segtree(){}
	Segtree(int n):N(n){dat=vector<int>(2*n);}
	void update(int k,int x){
		k+=N;
		dat[k]+=x;
		while(k>1){
			k>>=1;
			dat[k]=dat[k*2]+dat[k*2+1];
		}
	}
	int query(int l,int r){
		int res=0;
		for(l+=N,r+=N;l<r;l>>=1,r>>=1){
			if(l&1)res+=dat[l++];
			if(r&1)res+=dat[--r];
		}
		return res;
	}
};

struct Chain;

struct Chain{
	int id;
	vector<int>nodes;
	set<int>black;
	Segtree tree;
	int cur;

	bool init(){
		if(nodes.empty())return false;
		black.insert(-1);
		black.insert(nodes.size());
		id=nodes[0];
		cur=0;
		tree=Segtree(nodes.size());
		return true;
	}
	void update();
	int get(int v){
		assert(!black.count(v));
		auto l=black.lower_bound(v);
		auto r=l;l--;
		int L=*l,R=*r;
		return R-L-1+tree.query(L+1,R-1);
	}
};

Chain chain[200000];

void Chain::update(){
	if(par[id]==-1)return;
	int r=*++black.begin();
	auto&t=chain[belong[par[id]]].tree;
	t.update(cid[par[id]],-cur);
	int sum=tree.query(0,r)+r;
	cur=sum;
	t.update(cid[par[id]],cur);
}

int node_num;

void dfs(int v,int p,int d){
	sz[v]=1;
	par[v]=p;
	dep[v]=d;
	for(int u:E[v]){
		if(u==p)continue;
		dfs(u,v,d+1);
		sz[v]+=sz[u];
	}
}

void hld(int v,int k){
	vid[v]=node_num++;
	belong[v]=k;
	cid[v]=chain[k].nodes.size();
	chain[k].nodes.push_back(v);
	int Max=0,id=-1;
	for(int u:E[v]){
		if(u==par[v])continue;
		if(Max<sz[u])Max=sz[u],id=u;
	}
	if(id==-1)return;
	hld(id,k);
	for(int u:E[v]){
		if(u==par[v]||u==id)continue;
		hld(u,u);
	}
}

int find_par(int v){
	int b=belong[v],c=cid[v];
	auto it=chain[b].black.lower_bound(c);it--;
	if(it!=chain[b].black.begin())return v;
	else if(par[b]==-1||col[par[b]]==1)return v;
	return find_par(par[b]);
}

void update_par(int v){
	int b=belong[v];
	chain[b].update();
	if(par[b]!=-1)update_par(par[b]);
}

int main(){
	int n,q;cin>>n>>q;
	assert(1<=n&&n<=100000);
	assert(1<=q&&q<=100000);
	rep(i,n-1){
		int a,b;scanf("%d%d",&a,&b);a--;b--;
		assert(0<=a&&a<n);
		assert(0<=b&&b<n);
		assert(a!=b);
		E[a].push_back(b);
		E[b].push_back(a);
	}
	dfs(0,-1,0);
	hld(0,0);
	vector<P>vs;
	rep(i,n){
		if(!chain[i].init())continue;
		vs.push_back(P(dep[i],i));
	}
	sort(vs.begin(),vs.end());
	for(int i=vs.size()-1;i>=0;i--){
		chain[vs[i].second].update();
	}
	//~ rep(i,n){
		//~ cout<<"par="<<find_par(i)<<endl;
		//~ int x=find_par(i);
		//~ cout<<chain[belong[x]].get(cid[x])<<endl;
	//~ }
	rep(i,q){
		int ty,v;scanf("%d%d",&ty,&v);v--;
		if(ty==1){
			int b=belong[v],c=cid[v];
			if(col[v])chain[b].black.erase(c);
			col[v]^=1;
			if(col[v])chain[b].black.insert(c);
			update_par(belong[v]);
		}
		else{
			int x=find_par(v);
			printf("%d\n",chain[belong[x]].get(cid[x]));
		}
	}
}
accuracy: 0.2
time_ms: 100
memory_kb: 47032
final_rank: 4

code_snippet: #include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
typedef pair<int,int>P;

vector<int>E[200000];
int sz[200000];
int vid[200000];
int par[200000];
int dep[200000];

int belong[200000];
int cid[200000];
int col[200000];

struct Segtree{
	int N;
	vector<int>dat;
	Segtree(){}
	Segtree(int n):N(n){dat=vector<int>(2*n);}
	void update(int k,int x){
		k+=N;
		dat[k]+=x;
		while(k>1){
			k>>=1;
			dat[k]=dat[k*2]+dat[k*2+1];
		}
	}
	int query(int l,int r){
		int res=0;
		for(l+=N,r+=N;l<r;l>>=1,r>>=1){
			if(l&1)res+=dat[l++];
			if(r&1)res+=dat[--r];
		}
		return res;
	}
};

struct Chain;

struct Chain{
	int id;
	vector<int>nodes;
	set<int>black;
	Segtree tree;
	int cur;

	bool init(){
		if(nodes.empty())return false;
		black.insert(-1);
		black.insert(nodes.size());
		id=nodes[0];
		cur=0;
		tree=Segtree(nodes.size());
		return true;
	}
	void update();
	int get(int v){
		assert(!black.count(v));
		auto l=black.lower_bound(v);
		auto r=l;l--;
		int L=*l,R=*r;
		return R-L-1+tree.query(L+1,R);
	}
};

Chain chain[200000];

void Chain::update(){
	if(par[id]==-1)return;
	int r=*++black.begin();
	auto&t=chain[belong[par[id]]].tree;
	t.update(cid[par[id]],-cur);
	int sum=tree.query(0,r)+r;
	cur=sum;
	t.update(cid[par[id]],cur);
}

int node_num;

void dfs(int v,int p,int d){
	sz[v]=1;
	par[v]=p;
	dep[v]=d;
	for(int u:E[v]){
		if(u==p)continue;
		dfs(u,v,d+1);
		sz[v]+=sz[u];
	}
}

void hld(int v,int k){
	vid[v]=node_num++;
	belong[v]=k;
	cid[v]=chain[k].nodes.size();
	chain[k].nodes.push_back(v);
	int Max=0,id=-1;
	for(int u:E[v]){
		if(u==par[v])continue;
		if(Max<sz[u])Max=sz[u],id=u;
	}
	if(id==-1)return;
	hld(id,k);
	for(int u:E[v]){
		if(u==par[v]||u==id)continue;
		hld(u,u);
	}
}

int find_par(int v){
	int b=belong[v],c=cid[v];
	auto it=chain[b].black.lower_bound(c);it--;
	if(it!=chain[b].black.begin())return v;
	else if(par[b]==-1||col[par[b]]==1)return v;
	return find_par(par[b]);
}

void update_par(int v){
	int b=belong[v];
	chain[b].update();
	if(par[b]!=-1)update_par(par[b]);
}

int main(){
	int n,q;cin>>n>>q;
	assert(1<=n&&n<=100000);
	assert(1<=q&&q<=100000);
	rep(i,n-1){
		int a,b;scanf("%d%d",&a,&b);a--;b--;
		assert(0<=a&&a<n);
		assert(0<=b&&b<n);
		assert(a!=b);
		E[a].push_back(b);
		E[b].push_back(a);
	}
	dfs(0,-1,0);
	hld(0,0);
	vector<P>vs;
	rep(i,n){
		if(!chain[i].init())continue;
		vs.push_back(P(dep[i],i));
	}
	sort(vs.begin(),vs.end());
	for(int i=vs.size()-1;i>=0;i--){
		chain[vs[i].second].update();
	}
	//~ rep(i,n){
		//~ cout<<"par="<<find_par(i)<<endl;
		//~ int x=find_par(i);
		//~ cout<<chain[belong[x]].get(cid[x])<<endl;
	//~ }
	rep(i,q){
		int ty,v;scanf("%d%d",&ty,&v);v--;
		if(ty==1){
			int b=belong[v],c=cid[v];
			if(col[v])chain[b].black.erase(c);
			col[v]^=1;
			if(col[v])chain[b].black.insert(c);
			update_par(belong[v]);
		}
		else{
			int x=find_par(v);
			printf("%d\n",chain[belong[x]].get(cid[x]));
		}
	}
}
accuracy: 1
time_ms: 110
memory_kb: 47120
final_rank: 1