NOIP2016天天爱跑步

最新推荐文章于 2024-06-28 12:42:10 发布

罗旅洲

最新推荐文章于 2024-06-28 12:42:10 发布

阅读量3.6k

点赞数 1

分类专栏： NOIP题目 LCA

本文链接：https://blog.csdn.net/Pig_cfbsl/article/details/78482746

版权

NOIP题目同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

LCA

6 篇文章 0 订阅

订阅专栏

题目在这

题目描述

小c同学认为跑步非常有趣,于是决定制作一款叫做《天天爱跑步》的游戏。«天天爱跑步»是一个养成类游戏,需要玩家每天按时上线,完成打卡任务。

这个游戏的地图可以看作一一棵包含 $n$ 个结点和 $n - 1$ 条边的树, 每条边连接两个结点,且任意两个结点存在一条路径互相可达。树上结点编号为从 $1$ 到 $n$ 的连续正整数。

现在有 $m$ 个玩家,第 $i$ 个玩家的起点为 $S_i$ ,终点为 $T_i$ 。每天打卡任务开始时,所有玩家在第 $0$ 秒同时从自己的起点出发, 以每秒跑一条边的速度, 不间断地沿着最短路径向着自己的终点跑去, 跑到终点后该玩家就算完成了打卡任务。 (由于地图是一棵树, 所以每个人的路径是唯一的)

小C想知道游戏的活跃度, 所以在每个结点上都放置了一个观察员。在结点 $j$ 的观察员会选择在第 $W_j$ 秒观察玩家, 一个玩家能被这个观察员观察到当且仅当该玩家在第 $W_j$ 秒也理到达了结点 $j$ 。小C想知道每个观察员会观察到多少人?

注意: 我们认为一个玩家到达自己的终点后该玩家就会结束游戏, 他不能等待一段时间后再被观察员观察到。即对于把结点 $j$ 作为终点的玩家: 若他在第 $W_j$ 秒前到达终点,则在结点 $j$ 的观察员不能观察到该玩家;若他正好在第 $W_j$ 秒到达终点,则在结点 $j$ 的观察员可以观察到这个玩家。

输入输出格式

输入格式：

第一行有两个整数 $n$ 和 $m$ 。其中 $n$ 代表树的结点数量, 同时也是观察员的数量, $m$ 代表玩家的数量。

接下来 $n - 1$ 行每行两个整数 $u$ 和 $v$ ,表示结点 $u$ 到结点 $v$ 有一条边。

接下来一行 $n$ 个整数,其中第 $j$ 个整数为 $W_j$ , 表示结点 $j$ 出现观察员的时间。

接下来 $m$ 行,每行两个整数 $S_i$ ,和 $T_i$ ,表示一个玩家的起点和终点。

对于所有的数据,保证 $1≤Si,Ti≤n,0≤Wj≤n1\leq S_i,T_i\leq n, 0\leq W_j\leq n$ 。

输出格式：

输出1行 $n$ 个整数,第 $j$ 个整数表示结点 $j$ 的观察员可以观察到多少人。

输入输出样例

输入样例#1： 复制

6 3
2 3
1 2 
1 4 
4 5 
4 6 
0 2 5 1 2 3 
1 5 
1 3 
2 6

输出样例#1： 复制

2 0 0 1 1 1

输入样例#2： 复制

输出样例#2： 复制

1 2 1 0 1

说明

【样例1说明】

对于1号点， $W_i=0$ ，故只有起点为1号点的玩家才会被观察到，所以玩家1和玩家2被观察到，共有2人被观察到。

对于2号点，没有玩家在第2秒时在此结点，共0人被观察到。

对于3号点，没有玩家在第5秒时在此结点，共0人被观察到。

对于4号点，玩家1被观察到，共1人被观察到。

对于5号点，玩家1被观察到，共1人被观察到。

对于6号点，玩家3被观察到，共1人被观察到。

【子任务】

每个测试点的数据规模及特点如下表所示。提示: 数据范围的个位上的数字可以帮助判断是哪一种数据类型。

题解

a[x]表示x点的观察员观察时间,s为起点,t为终点

以下是所有部分分(80分)

1.直接爆搜,复杂度O(NM)

2.对于一条链的情况:对于点x,只有可能从x+a[x] or x-a[x] 为起点的路线且要求终点穿过该点,把每一条路线的方向(正负),长度(t-s)用vector压入起点位置,再O(N)扫一遍即可.复杂度应该大约可能为O(N+M)左右

3.对于起点为1的情况,以1为根的树节点的深度就是到达的时间,如果dep[x]=a[x]则该点的答案为其子树内终点的个数.复杂度:O(N)

4.对于终点为1的情况:以1为根的树节点的答案就是子树内深度为dep[x]+a[x]的终点个数,若对于每一个点都搜索一遍子树,复杂度为O(N^2),但每一次最后去搜重儿子,把重儿子的桶直接利用,(就是树上启发式合并)复杂度为O(N lgN)

#include<bits/stdc++.h>
using namespace std;
#define For(i,a,b) for(register int i=(a);i<=(b);++i)
#define pb push_back
const int maxx=3e5+5;
int read(){
    char x=getchar(); int u=0;
    while(!isdigit(x)) x=getchar();
    while(isdigit(x)) u=(u<<3)+(u<<1)+(x^48), x=getchar();
    return u;
}
int be[maxx],ne[maxx<<1],to[maxx<<1],e=0,a[maxx],n,m;
struct node{
    int s,t;
}play[maxx];
void add(int x,int y){
    to[++e]=y;
    ne[e]=be[x];
    be[x]=e;
}
// pts:25
bool flag;
int end,ans[maxx];
void dfs(int id,int fa,int ti){
    if(id==end){
        if(ti==a[id]) ans[id]++;
        flag=1;
        return ;
    }
    for(int i=be[id];i;i=ne[i]){
        if(to[i]==fa || flag) continue;
        dfs(to[i],id,ti+1);
        if(flag && a[id]==ti) ans[id]++;
    }
}
void solve1(){
    For(i,1,m){
        flag=0;
        end=play[i].t;
        dfs(play[i].s,0,0);
    }
    For(i,1,n) printf("%d ",ans[i]);
}
// pts:15
vector<int> q[100000];
void solve2(){
    For(i,1,m){
        q[play[i].s].pb(play[i].t-play[i].s);
//		printf("%d %d\n",play[i].s,play[i].t-play[i].s);
    }
    int pos,ans;
    For(i,1,n){
        pos=i-a[i]; ans=0;
        if(!a[i]){
            ans=q[i].size();
            printf("%d ",ans);
            continue;
        }
        if(pos>0) 
            for(int j=0;j<q[pos].size();++j)
                if(q[pos][j]>=a[i]) ++ans;
        pos=i+a[i];
        if(pos<=n)
            for(int j=0;j<q[pos].size();++j)
                if(q[pos][j]<=-a[i]) ++ans;
        printf("%d ",ans);
    }
}
// pts:20
int size[maxx];
void DFS(int id,int fa,int dep){
	size[id]+=q[id].size();
	for(int i=be[id];i;i=ne[i]){
		int go=to[i];
		if(go==fa) continue;
		DFS(go,id,dep+1);
		size[id]+=size[go];
	}
	if(dep==a[id]) ans[id]=size[id];
}
void solve3(){
	For(i,1,m) q[play[i].t].pb(0);
	DFS(1,0,0);
	For(i,1,n) printf("%d ",ans[i]);
}
// pts:20
int son[maxx];
bool skip[maxx];
void dfs_init(int id,int fa){
	size[id]=1;
	for(int i=be[id];i;i=ne[i]){
		int go=to[i];
		if(go==fa) continue;
		dfs_init(go,id);
		size[id]+=size[go];
		if(!son[id] || size[go]>size[son[id]]) son[id]=go;
	}
}
void change(int x,int f,int dep,int k){
	size[dep]+=k*q[x].size();
	for(int i=be[x];i;i=ne[i])
		if(to[i]!=f && !skip[to[i]])
			change(to[i],x,dep+1,k);
}
void bfs(int id,int fa,int dep,bool keep){
	for(int i=be[id];i;i=ne[i])
		if(to[i]!=son[id] && to[i]!=fa) 
			bfs(to[i],id,dep+1,0);
	if(son[id]){ bfs(son[id],id,dep+1,1); skip[son[id]]=1; }
	change(id,fa,dep,1);
	if(dep+a[id]<=n) ans[id]+=size[dep+a[id]];
	if(son[id]) skip[son[id]]=0;
	if(!keep) change(id,fa,dep,-1);
}
void solve4(){
	dfs_init(1,0);
	For(i,1,n) size[i]=0;
	For(i,1,m) q[play[i].s].pb(0);
	bfs(1,0,0,0);
	For(i,1,n) printf("%d ",ans[i]);
}
int main(){
	freopen("1.in","r",stdin);
	freopen("a.out","w",stdout);
    int u,v;
    n=read(); m=read();
    For(i,1,n-1){
        u=read(); v=read();
        add(u,v); add(v,u);
    }
    For(i,1,n) a[i]=read();
    For(i,1,m) play[i].s=read(), play[i].t=read();
    if(n<=1000) solve1();
    else if(n%10==4) solve2();
    else if(n%10==5) solve3();
	else if(n%10==6) solve4();
    return 0;
}

正解

对于暴力的第四档已经就是正解做法了,再结合树上差分一下就可以A了.

对于点x可以计入贡献的情况:

dep[x]+a[x]=dep[s]

dep[s]-a[x]=2*dep[lca(s,t)]-dep[s]

再随便打几个标记,开个桶维护一下,注意再lca处要加一个减的标记,lca的父亲处也加一个减的标记,这样既可以算到lca处的答案,也不会算两遍,dfs时继续启发式合并.复杂度(N lgN)

#include<bits/stdc++.h>
using namespace std;
#define For(i,a,b) for(register int i=(a);i<=(b);++i)
#define pb push_back
const int maxx=3e5+5,N=1e6;
int read(){
    char x=getchar(); int u=0;
    while(!isdigit(x)) x=getchar();
    while(isdigit(x)) u=(u<<3)+(u<<1)+(x^48), x=getchar();
    return u;
}
int be[maxx],ne[maxx<<1],to[maxx<<1],a[maxx],n,m,e=0,ans[maxx];
int size[maxx],son[maxx],fa[maxx],dep[maxx],jump[maxx],skip[maxx],tong[20000000];
struct node{ int val; bool type; };
vector<node>q[maxx];
inline void add(int x,int y){
    to[++e]=y;
    ne[e]=be[x];
    be[x]=e;
}
inline void dfs_init(int id){
    size[id]=1;
    for(int i=be[id];i;i=ne[i]){
        int go=to[i];
        if(go==fa[id]) continue;
        fa[go]=id; dep[go]=dep[id]+1;
        dfs_init(go);
        size[id]+=size[go];
        if(size[go]>size[son[id]]) son[id]=go;
    }
}
inline void dfs_jump(int id,int top){
    jump[id]=top;
    if(!son[id]) return;
    dfs_jump(son[id],top);
    for(int i=be[id];i;i=ne[i])
        if(to[i]!=fa[id] && to[i]!=son[id])
            dfs_jump(to[i],to[i]);
}
int lca(int x,int y){
    while(jump[x]^jump[y]){
        if(dep[jump[x]]<dep[jump[y]]) swap(x,y);
        x=fa[jump[x]];
    }
    if(dep[x]>dep[y]) swap(x,y);	
    return x;
}
inline void change(int id,int fa,bool k){
    for(int i=0;i<q[id].size();++i)
        tong[q[id][i].val]+=(k^q[id][i].type)?-1:1;
    for(int i=be[id];i;i=ne[i])
        if(to[i]!=fa && !skip[to[i]])
            change(to[i],id,k);
}
inline void dfs(int id,int fa,bool keep){
    for(int i=be[id];i;i=ne[i])
        if(to[i]!=fa && to[i]!=son[id])
            dfs(to[i],id,0);
    if(son[id]){ dfs(son[id],id,1); skip[son[id]]=1; }
    change(id,fa,1);
    ans[id]+=tong[dep[id]+a[id]]+tong[dep[id]-a[id]+N];
    if(son[id]) skip[son[id]]=0;
    if(!keep) change(id,fa,0);
}
int main(){
	freopen("1.in","r",stdin);
	freopen("1.out","w",stdout);
	int u,v,LCA;
    n=read(); m=read();
    For(i,1,n-1){
        u=read(); v=read();
        add(u,v); add(v,u);
    }
    fa[1]=0; dfs_init(1); dfs_jump(1,1);
    For(i,1,n) a[i]=read();
    For(i,1,m){
        u=read(), v=read();
 		LCA=lca(u,v);
        q[u].pb((node){dep[u],1});
        q[LCA].pb((node){dep[u],0});
        q[v].pb((node){N+2*dep[LCA]-dep[u],1});
        q[fa[LCA]].pb((node){N+2*dep[LCA]-dep[u],0});
    }
    dfs(1,0,0);
    For(i,1,n) printf("%d ",ans[i]);
    return 0;
}