The 2018 ACM-ICPC Asia Qingdao Regional Contest, Online B Red Black Tree (LCA)

题目链接:

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=5807

 

题意:

给一棵n个节点的红黑树,每条边有距离。树上有m个点是红的,每个红点的cost是0,每个黑点的cost是离它最近的红点祖先到它的距离。

q个询问,每次给k个点,现在允许你将树上某个点变红,是这k个点的cost的最大值最小,输出这个值。(数据规模都是10w)

 

思路1:

把每个红点与它父亲断开,这样就有很多棵根节点红色其他节点黑色的树(红根树)。

每次询问k个点,我们只需要考虑它们所在的红根树当中,max(cost)最大和次大的两棵树。

现在要选某个点变红,肯定是选在最大的红根树里。将max(cost)最小化后,和次大的树比一下就行了。

问题转化成,在红根树里选一个点变红,使k'个点的max(cost)最小。那就把k'个点按cost从小到大排序,求k'个后缀LCA就行了。

(可惜比赛的时候一句话写错了,搞半天还以为思路错了)

复杂度:O(n*log(n))

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,ll> P;
const int N=100005;
int red[N];
int redfa[N];
vector<P>link[N];
ll cost[N];
int deep[N];
int sz[N],son[N],fa[N];
void dfs(int u,int _fa,int _red,ll _cost,int _deep){
	fa[u]=_fa;
	deep[u]=_deep;
	cost[u]=_cost;
	redfa[u]=_red;
	sz[u]=1;
	son[u]=-1;
	for (P p:link[u]){
		int v=p.first; ll w=p.second;
		if (v==_fa) continue;
		if (red[v]) dfs(v,u,v,0,_deep+1);
		else dfs(v,u,_red,_cost+w,_deep+1);
		sz[u]+=sz[v];
		if (son[u]==-1||sz[v]>sz[son[u]]) son[u]=v;
	}
}
int top[N],id[N],T;
void dfs2(int u,int _fa,int p){
    top[u]=p;
    id[u]=++T;
    if (son[u]!=-1) dfs2(son[u],u,p);
	for (P p:link[u]){
		int v=p.first; ll w=p.second;
        if (v==_fa||v==son[u]) continue;
        dfs2(v,u,v);
    }
}
int getlca(int x,int y){
	if (x==0) return y;
    int f1=top[x],f2=top[y];
    while(f1!=f2){
        if (deep[f1]<deep[f2]) swap(f1,f2),swap(x,y);
        x=fa[f1],f1=top[x];
    }
    if (deep[x]<deep[y]) swap(x,y);
    return y;
}
int stk[N];
int que[N];
ll f[N];
vector<int>VS[N];
int vis[N];
bool cmp(int i,int j){
	return f[i]>f[j];
}
bool cmp2(int i,int j){
	return cost[i]<cost[j];
}
int main(){
	int t; scanf("%d",&t);
	while(t--){
		int n,m,q; scanf("%d%d%d",&n,&m,&q);
		for (int i=1;i<=m;i++){
			int x; scanf("%d",&x);
			red[x]=1;
		}
		for (int i=1;i<n;i++){
			int x,y; ll w; scanf("%d%d%lld",&x,&y,&w);
			link[x].push_back({y,w});
			link[y].push_back({x,w});
		}
		dfs(1,0,1,0,1);
		dfs2(1,0,1);
		for (int T=1;T<=q;T++){
			int num; scanf("%d",&num);
			int top=0;
			for (int i=1;i<=num;i++){
				scanf("%d",&que[i]);
				int _red=redfa[que[i]];
				VS[_red].emplace_back(que[i]);
				if (vis[_red]!=T) stk[++top]=_red,f[_red]=cost[que[i]];
				else f[_red]=max(f[_red],cost[que[i]]);
				vis[_red]=T;
			}
			sort(stk+1,stk+top+1,cmp);
			int _red=stk[1];
			sort(VS[_red].begin(),VS[_red].end(),cmp2);
			int tot=VS[_red].size();
			ll ret = cost[VS[_red][tot - 1]];
			int lca=VS[_red][tot - 1];
			for (int i=tot-1;i>=0;i--){
				lca=getlca(lca,VS[_red][i]);
				ll tmp;
				if (i!=0) tmp=cost[VS[_red][i-1]];
				else tmp=0;
				ret=min(ret,max(tmp,f[_red]-cost[lca]));
			}
			if (top==1) printf("%lld\n",ret);
			else printf("%lld\n",max(ret,f[stk[2]]));
			for (int i=1;i<=top;i++) VS[stk[i]].clear();
		}
		for (int i=1;i<=n;i++){
			link[i].clear();
			red[i]=0;
			vis[i]=0;
		}
	}
}

 

思路2:

二分答案,不满足答案的LCA合并起来再看是否满足。(大家基本是这么做的)

复杂度:O(n*log(1e14)*log(n))     但是树链剖分求LCA实在是太快了,也能过

求LCA的地方还可以转RMQ用ST表做到O(1),就是写起来比较麻烦

(试了下倍增求LCA,T掉了,果然树剖大法好!)

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,ll> P;
const int N=100005;
int red[N];
int redfa[N];
vector<P>link[N];
ll cost[N];
int deep[N];
int que[N];
int sz[N],son[N],fa[N];
void dfs(int u,int _fa,int _red,ll _cost,int _deep){
	fa[u]=_fa;
	deep[u]=_deep;
	cost[u]=_cost;
	redfa[u]=_red;
	sz[u]=1;
	son[u]=-1;
	for (P p:link[u]){
		int v=p.first; ll w=p.second;
		if (v==_fa) continue;
		if (red[v]) dfs(v,u,v,0,_deep+1);
		else dfs(v,u,_red,_cost+w,_deep+1);
		sz[u]+=sz[v];
		if (son[u]==-1||sz[v]>sz[son[u]]) son[u]=v;
	}
}
int top[N],id[N],T;
void dfs2(int u,int _fa,int p){
    top[u]=p;
    id[u]=++T;
    if (son[u]!=-1) dfs2(son[u],u,p);
	for (P p:link[u]){
		int v=p.first; ll w=p.second;
        if (v==_fa||v==son[u]) continue;
        dfs2(v,u,v);
    }
}
int getlca(int x,int y){
	if (x==0) return y;
    int f1=top[x],f2=top[y];
    while(f1!=f2){
        if (deep[f1]<deep[f2]) swap(f1,f2),swap(x,y);
        x=fa[f1],f1=top[x];
    }
    if (deep[x]<deep[y]) swap(x,y);
    return y;
}
bool check(ll len,int num){
	int lca=0;
	for (int i=1;i<=num;i++)
		if (cost[que[i]]>len) lca=getlca(lca,que[i]);
	for (int i=1;i<=num;i++)
		if (cost[que[i]]>len){
			if (deep[redfa[que[i]]]>=deep[lca]) return 0;
			if (cost[que[i]]-cost[lca]>len) return 0;
		}
	return 1;
}
int main(){
	int t; scanf("%d",&t);
	while(t--){
		int n,m,q; scanf("%d%d%d",&n,&m,&q);
		for (int i=1;i<=m;i++){
			int x; scanf("%d",&x);
			red[x]=1;
		}
		for (int i=1;i<n;i++){
			int x,y; ll w; scanf("%d%d%lld",&x,&y,&w);
			link[x].push_back({y,w});
			link[y].push_back({x,w});
		}
		dfs(1,0,1,0,1);
		dfs2(1,0,1);
		for (int T=1;T<=q;T++){
			int num; scanf("%d",&num);
			for (int i=1;i<=num;i++) scanf("%d",&que[i]);
			ll l=0,r=1e14;
			while(l<r){
				ll mid=(l+r)/2;
				if (!check(mid,num)) l=mid+1;
				else r=mid;
			}
			printf("%lld\n",l);
		}
		for (int i=1;i<=n;i++){
			link[i].clear();
			red[i]=0;
			deep[i]=0;
		}
	}
}

 

 

HDU 5052 树链剖分

题意:给你一棵树,每个点有点权,问从x走到y,先后取两个数a和b,b-a的最大值。

 

做法:树链剖分一下,然后线段树把路径区间都合并起来。

 

比赛的时候居然没想出来。。。(现在想想不是很简单嘛。。。)

 

#include<cstdio>
#include<algorithm>
using namespace std;
const int N=50005;
int a[N];
int base[N],vec[2*N],pre[2*N],tot;
int id[N],rd[N],son[N],deep[N],size[N],fa[N],top[N];
int T;
int n;
void link(int x,int y)
{
	vec[++tot]=y; pre[tot]=base[x]; base[x]=tot;
}

struct seg
{
	int ma,mi,fl,fr;
	seg operator+(const seg &t)const
	{
		if (ma==-1) return t;
		if (t.ma==-1) return *this;
		int maa=max(ma,t.ma);
		int mii=min(mi,t.mi);
		int ffl=max(fl,t.fl);
		ffl=max(ffl,ma-t.mi);
		int ffr=max(fr,t.fr);
		ffr=max(ffr,t.ma-mi);
		return {maa,mii,ffl,ffr};
	}
	void operator+=(const int t)
	{
		ma+=t; mi+=t;
	}
}s[4*N];
int lazy[4*N];
void build(int i,int l,int r)
{
	lazy[i]=0;
	if (l==r)
	{
		s[i]={a[rd[l]],a[rd[l]],0};
		return;
	}
	int mid=(l+r)/2;
	build(i*2,l,mid);
	build(i*2+1,mid+1,r);
	s[i]=s[i*2]+s[i*2+1];
}
void pd(int i)
{
	if (lazy[i])
	{
		lazy[i*2]+=lazy[i];
		lazy[i*2+1]+=lazy[i];
		s[i*2]+=lazy[i];
		s[i*2+1]+=lazy[i];
		lazy[i]=0;
	}
}
void add(int i,int l,int r,int x,int y,int z)
{
	if (x<=l&&r<=y)
	{
		s[i]+=z;
		lazy[i]+=z;
		return;
	}
	pd(i);
	int mid=(l+r)/2;
	if (x<=mid) add(i*2,l,mid,x,y,z);
	if (y>mid) add(i*2+1,mid+1,r,x,y,z);
	s[i]=s[i*2]+s[i*2+1];
}
seg get(int i,int l,int r,int x,int y)
{
	if (x<=l&&r<=y) return s[i];
	pd(i);
	int mid=(l+r)/2;
	seg tmp={-1,-1,-1,-1};
	if (x<=mid) tmp=tmp+get(i*2,l,mid,x,y);
	if (y>mid) tmp=tmp+get(i*2+1,mid+1,r,x,y);
	return tmp;
}


void dfs1(int u,int d,int p)
{
	fa[u]=p;
	deep[u]=d;
	son[u]=-1;
	size[u]=1;
	for (int now=base[u];now;now=pre[now])
	{
		int v=vec[now];
		if (v==p) continue;
		dfs1(v,d+1,u);
		size[u]+=size[v];
		if (son[u]==-1||size[v]>size[son[u]]) son[u]=v;
	}
}
void dfs2(int u,int p)
{
	top[u]=p;
	id[u]=++T;
	rd[T]=u;
	if (son[u]!=-1) dfs2(son[u],p);
	for (int now=base[u];now;now=pre[now])
	{
		int v=vec[now];
		if (v==fa[u]||v==son[u]) continue;
		dfs2(v,v);
	}
}

int lca(int x,int y)
{
	int f1=top[x],f2=top[y];
	while(f1!=f2)
	{
		if (deep[f1]<deep[f2]) swap(f1,f2),swap(x,y);
		x=fa[f1],f1=top[x];
	}
	if (deep[x]<deep[y]) swap(x,y);
	return y;
}

seg getseg(int x,int LCA,int v)
{
	seg tmp={-1,-1,-1,-1};
	while(x!=LCA&&deep[top[x]]>deep[LCA])
	{
		tmp=get(1,1,n,id[top[x]],id[x])+tmp;
		add(1,1,n,id[top[x]],id[x],v);
		x=fa[top[x]];
	}
	tmp=get(1,1,n,id[LCA],id[x])+tmp;
	add(1,1,n,id[LCA],id[x],v);
	return tmp;
}
int solve(int x,int y,int v)
{
	int LCA=lca(x,y);

	seg tmp1=getseg(x,LCA,v);
	add(1,1,n,id[LCA],id[LCA],-v);
	seg tmp2=getseg(y,LCA,v);

	int ans=max(tmp1.fl,tmp2.fr);
	ans=max(ans,tmp2.ma-tmp1.mi);
	return ans;
}

int main()
{
	int t; scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&n);
		for (int i=1;i<=n;i++) scanf("%d",&a[i]);
		for (int i=1;i<n;i++)
		{
			int x,y;
			scanf("%d%d",&x,&y);
			link(x,y);
			link(y,x);
		}

		dfs1(1,1,-1);
		dfs2(1,-1);
		build(1,1,n);

		int q;
		scanf("%d",&q);
		while(q--)
		{
			int x,y,v;
			scanf("%d%d%d",&x,&y,&v);
			printf("%d\n",solve(x,y,v));
		}
		tot=T=0;
		for (int i=1;i<=n;i++) base[i]=0;
	}
}

hdu 4897(树剖好题)

题意:

一棵树,一开始所有边都是白的,3种操作。

1.把a到b路径上的边变色(白变黑,黑变白)

2.把与所有(a到b路径上的点)相连的边都改变颜色(不包括路径上的边)

3.询问a到b路径上有多少黑边

 

做法:

先树链剖分

如果只有操作1,就是普通的线段树维护重链的做法。

但是有操作2,暴力修改所有儿子的话每次都是O(n),于是想到把要不要变色的信息存在父节点,查询的时候查一下父节点是否要求它变色。

 

具体怎么修改就是轻重边分开考虑。先把所有路径上的点都在point线段树里修改。

对于路径上的轻边,因为它父亲被改变了而这条轻边是不用修改的,那就把这条轻边在edge线段树里修改来抵消父亲对它的影响。

对于路径外需要修改的重边,直接在edge线段树上修改。(这样的重边只有logn条)

 

查询的时候,对于路径上的重边,直接在边的线段树上求答案,对于路径上的轻边,还要结合它的父亲来判断它是否是黑的。

 

代码应该还是比较好懂的。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=100005;
int size[N],top[N],son[N],fa[N],id[N],rd[N],deep[N],n,idn;
int base[N],vec[2*N],pre[2*N],tot;
struct SegTree{
	int f[4*N],sum[4*N];
	bool lazy[4*N];
	void build(int i,int l,int r)
	{
		if (l==r) {sum[i]=1; f[i]=0; lazy[i]=0; return;}
		int mid=(l+r)/2;
		build(i*2,l,mid);
		build(i*2+1,mid+1,r);
		sum[i]=sum[i*2]+sum[i*2+1];
		f[i]=0; lazy[i]=0;
	}
	void pd(int i)
	{
		if (lazy[i])
		{
			lazy[i]=0;
			f[i*2]=sum[i*2]-f[i*2];
			f[i*2+1]=sum[i*2+1]-f[i*2+1];
			lazy[i*2]^=1;
			lazy[i*2+1]^=1;
		}
	}
	void up(int i)
	{
		f[i]=f[i*2]+f[i*2+1];
	}
	void add(int i,int l,int r,int x,int y)
	{
		if (x>y) return;
		if (x<=l&&r<=y)
		{
			f[i]=sum[i]-f[i];
			lazy[i]^=1;
			return ;
		}
		pd(i);
		int mid=(l+r)/2;
		if (x<=mid) add(i*2,l,mid,x,y);
		if (y>mid) add(i*2+1,mid+1,r,x,y);
		up(i);
	}
	int get(int i,int l,int r,int x,int y)
	{
		if (x>y) return 0;
		if (x<=l&&r<=y) return f[i];
		pd(i);
		int tmp=0;
		int mid=(l+r)/2;
		if (x<=mid) tmp+=get(i*2,l,mid,x,y);
		if (y>mid) tmp+=get(i*2+1,mid+1,r,x,y);
		return tmp;
	}
}edg,pnt;
void init()
{
	memset(top,0,sizeof(top));
	memset(son,-1,sizeof(son));
	memset(base,0,sizeof(base));
	tot=idn=0;
}
void link(int x,int y)
{
    tot++;
    vec[tot]=y;  pre[tot]=base[x];  base[x]=tot;
}
void dfs1(int u,int p)
{
	fa[u]=p;
    size[u]=1;
    son[u]=-1;
    for (int now=base[u];now;now=pre[now])
	{
        int v=vec[now];
        if (v==p) continue;
		deep[v]=deep[u]+1;
		dfs1(v,u);
		size[u]+=size[v];
		if (son[u]==-1||size[v]>size[son[u]]) son[u]=v;
    }
}
void dfs2(int u,int p)
{
	top[u]=p;
    id[u]=++idn;
	rd[idn]=u;
    if (son[u]!=-1) dfs2(son[u],p);
    for (int now=base[u];now;now=pre[now])
	{
		int v=vec[now];
		if (v==son[u]||v==fa[u]) continue;
        dfs2(v,v);
    }
}
void cg1(int a,int b)
{
    int f1=top[a]; int f2=top[b];
    while(f1!=f2)
    {
        if (deep[f1]<deep[f2]) swap(f1,f2),swap(a,b);
        int x=id[f1], y=id[a];
        edg.add(1,1,n,x,y);
        a=fa[f1]; f1=top[a];
    }
    if (deep[a]>deep[b]) swap(a,b);
    if (a==b) return;
    int x=id[a], y=id[b];
	edg.add(1,1,n,x+1,y);
}

void cg2(int a,int b)
{
	int f1=top[a]; int f2=top[b];
    while(f1!=f2)
    {
        if (deep[f1]<deep[f2]) swap(f1,f2),swap(a,b);
        int x=id[f1], y=id[a];
        pnt.add(1,1,n,x,y);
        edg.add(1,1,n,x,x);
        if (son[a]!=-1) edg.add(1,1,n,id[son[a]],id[son[a]]);
        a=fa[f1]; f1=top[a];
    }
    if (deep[a]>deep[b]) swap(a,b);
    int x=id[a], y=id[b];
	pnt.add(1,1,n,x,y);
	edg.add(1,1,n,x,x);
	if (son[b]!=-1) edg.add(1,1,n,id[son[b]],id[son[b]]);
}

int query(int a,int b)
{
	int ans=0;
	int f1=top[a]; int f2=top[b];
    while(f1!=f2)
    {
        if (deep[f1]<deep[f2]) swap(f1,f2),swap(a,b);
        int x=id[f1], y=id[a];
        ans+=edg.get(1,1,n,x+1,y);
        int tmp1=edg.get(1,1,n,x,x);
        int z=id[fa[f1]];
        int tmp2=pnt.get(1,1,n,z,z);
        ans+=tmp1^tmp2;
        a=fa[f1]; f1=top[a];
    }
    if (deep[a]>deep[b]) swap(a,b);
    int x=id[a], y=id[b];
	ans+=edg.get(1,1,n,x+1,y);
	return ans;
}

int main()
{
	int t;
	scanf("%d",&t);
    while(t--)
	{
		scanf("%d",&n);
		init();
		edg.build(1,1,n);
		pnt.build(1,1,n);
    	for (int i=1;i<n;i++)
		{
			int x,y;
			scanf("%d%d",&x,&y);
			link(x,y),link(y,x);
		}
    	dfs1(1,1);
    	dfs2(1,1);

    	int q;
    	scanf("%d",&q);
    	while(q--)
		{
			int tp,x,y;
			scanf("%d%d%d",&tp,&x,&y);
			if (tp==1)
			{
				cg1(x,y);
			}
			if (tp==2)
			{
				cg2(x,y);
				pnt.get(1,1,n,1,1);
			}
			if (tp==3)
			{
				printf("%d\n",query(x,y));
			}
		}
	}
}

 

 

bzoj-1036

终于学会了树链剖分,以前以为它很难,现在看来其实也挺简单的,就两个dfs+线段树维护一下嘛。第一次交忘记修改的是x对应的编号,WA了一次,修改后AC。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
#include<queue>
#include<functional>
using namespace std;
const int N=30005;
int size[N],top[N],son[N],f[N],id[N],c[N],w[N],deep[N],n,i,q,tot,idn,x,y;
int base[N],vec[2*N],pre[2*N];
struct node{
    int sum,mx,l,r,mid;
}tr[4*N];
char chr[10];
bool vis[N];
void add(int x,int y)
{
    tot++;
    vec[tot]=y;  pre[tot]=base[x];  base[x]=tot;
}
void dfs1(int u)
{
    vis[u]=true;
    int now=base[u];
    size[u]=1;
    while(now)
    {
        int v=vec[now];
        if (!vis[v])
        {
            f[v]=u;
            deep[v]=deep[u]+1;
            dfs1(v);
            size[u]+=size[v];
            if (size[v]>size[son[u]]) son[u]=v;
        }
        now=pre[now];
    }
}
void dfs2(int u)
{
    idn++; id[u]=idn;
    vis[u]=true;
    int now=base[u];
    if (son[u]) top[son[u]]=top[u],dfs2(son[u]);
    while(now)
    {
        int v=vec[now];
        if (!vis[v]) top[v]=v,dfs2(v);
        now=pre[now];
    }
}
void build(int i,int l,int r)
{
    tr[i].l=l; tr[i].r=r; tr[i].mid=(l+r)/2;
    if (l==r){tr[i].sum=tr[i].mx=c[l];return;}
    build(i*2,l,tr[i].mid);
    build(i*2+1,tr[i].mid+1,r);
    tr[i].sum=tr[i*2].sum+tr[i*2+1].sum;
    tr[i].mx=max(tr[i*2].mx,tr[i*2+1].mx);
}
int querymax(int i)
{
    if (x<=tr[i].l&&tr[i].r<=y) return tr[i].mx;
    if (y<=tr[i].mid) return querymax(i*2);
    if (x>tr[i].mid) return querymax(i*2+1);
    return max(querymax(i*2),querymax(i*2+1));
}
int querysum(int i)
{
    if (x<=tr[i].l&&tr[i].r<=y) return tr[i].sum;
    if (y<=tr[i].mid) return querysum(i*2);
    if (x>tr[i].mid) return querysum(i*2+1);
    return querysum(i*2)+querysum(i*2+1);
}
void change(int i)
{
    if (tr[i].l==tr[i].r) {tr[i].sum=y;tr[i].mx=y;return;}
    if (x<=tr[i].mid) change(i*2);else change(i*2+1);
    tr[i].sum=tr[i*2].sum+tr[i*2+1].sum;
    tr[i].mx=max(tr[i*2].mx,tr[i*2+1].mx);
}
void slovemax(int a,int b)
{
    int f1=top[a]; int f2=top[b];int tmp=-50000;
    while(f1!=f2)
    {
        if (deep[f1]<deep[f2]) swap(f1,f2),swap(a,b);
        x=id[f1];y=id[a];
        tmp=max(tmp,querymax(1));
        a=f[f1]; f1=top[a];
    }
    if (deep[a]>deep[b]) swap(a,b);
    x=id[a]; y=id[b];
    tmp=max(tmp,querymax(1));
    printf("%d\n",tmp);
}
void slovesum(int a,int b)
{
    int f1=top[a]; int f2=top[b];int tmp=0;
    while(f1!=f2)
    {
        if (deep[f1]<deep[f2]) swap(f1,f2),swap(a,b);
        x=id[f1];y=id[a];
        tmp+=querysum(1);
        a=f[f1]; f1=top[a];
    }
    if (deep[a]>deep[b]) swap(a,b);
    x=id[a]; y=id[b];
    tmp+=querysum(1);
    printf("%d\n",tmp);
}
int main()
{
    scanf("%d",&n);
    for (i=1;i<n;i++) scanf("%d%d",&x,&y),add(x,y),add(y,x);
    for (i=1;i<=n;i++) scanf("%d",&w[i]);
    deep[1]=1; dfs1(1);
    memset(vis,0,sizeof(vis));
    top[1]=1; dfs2(1);
    for (i=1;i<=n;i++) c[id[i]]=w[i];
    build(1,1,n);
    scanf("%d",&q);
    for (i=1;i<=q;i++)
    {
        scanf("%s%d%d",chr,&x,&y);
        if (chr[1]=='M') slovemax(x,y);
        if (chr[1]=='H') x=id[x],change(1);
        if (chr[1]=='S') slovesum(x,y);
    }
}