数据结构专题 - 解题报告 - M

首先感谢dalao前辈提供思路，整理如下：

读入数据并前向星建图
以1为根节点dfs走图建树，并标记已经走过（布尔型vis[ ]数组判断），以防走回父节点，然后深度（depth[ ]）逐级+1，且dis[to]=depth[to]（因为现在的最短距离是到根节点1的距离，即深度），然后搜下一个点。
建图完毕后倍增初始化。
m次循环，输入操作类型和操作点，
如果是染色，那么红色总点数++，为当前点，如果更新的点数与√n相等（学长教的分块思路），那么bfs更新这些点与全图黑点的距离（一种预处理），计数器归零，continue。
else，初始化ret=dis[x]（上一次遗留的最短dis记录），开始从1到cnt循环，找到没有分块处理过的但是染过色的点与当前点的距离（逐个比较的复杂度为最多为o(√n logn)，为优化最明显的地方），逐个与ret比较找最小值，打印ret并换行。

两点间距离求法：两个点的深度相加 - 2*公共祖先的点的深度。倍增lca求公共祖先的时间效率很可观，可以快速求出两点间距离（也是学长提示的）

bfs：
推入全部红点位置，dis[红点] = 0（自己到自己）
当队列有剩余元素时，循环节点的边，走图
更新最短路：如果存在 dis[now]+1 < dis[to] ，那么让dis[to] = dis[now] + 1，并推入to节点

更新一下，后来糖哥提示我如果分块是每50点一块的话跑的更快，我原本以sqrt(n)为块跑了950ms的代码改了之后只跑了311ms，爽了~

AC代码：

#include<bits/stdc++.h>
#define maxn 100005
#define maxm 200005
#define FOR(a, b, c) for(int a=b; a<=c; a++)
#define hrdg 1000000007
#define inf 2147483647
#define llinf 9223372036854775807
#define ll long long
#define pi acos(-1.0)
#define ls p<<1
#define rs p<<1|1
using namespace std;

inline int read()
{
    char c=getchar();long long x=0,f=1;
    while(c<'0'||c>'9'){if(c=='-') f=-1; c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0'; c=getchar();}
    return x*f;
}

int n, m, u, v, d, type, x, nn, cnt;
struct node{int to, nex, dis;}edge[maxn<<1];		
int head[maxn<<1], tot;
int depth[maxn], query[maxn], dis[maxn];		//分别代表深度，查询改为红色的点，最短距离
bool vis[maxn];
int f[maxn][32];			//倍增数组
queue<int> q;

void add(int u, int v)
{
    tot++;
    edge[tot].to = v;
    edge[tot].nex = head[u];
    head[u] = tot;
}

void dfs(int now)
{
    vis[now] = true;
    for(int i=head[now]; i; i=edge[i].nex)
    {
        int to = edge[i].to;
        if(vis[to])
            continue;
        depth[to] = depth[now] + 1;
        dis[to] = depth[to];
        f[to][0] = now;
        dfs(to);
    }
}

void pre()			//倍增初始化
{
    FOR(i, 1, 21)
        FOR(j, 1, n)
            f[j][i] = f[f[j][i-1]][i-1];
}

int lca(int x, int y)			//倍增求公共祖先
{
    if(depth[x] < depth[y])
        swap(x, y);
    for(int i=21; i>=0; i--)
        if(depth[f[x][i]] >= depth[y])
            x = f[x][i];
    if(x == y)
        return x;		
    for(int i=21; i>=0; i--)
        if(f[x][i] != f[y][i])
        {
            x = f[x][i];
            y = f[y][i];
        }
    return f[x][0];
}

int getdis(int x, int y){return depth[x] + depth[y] - 2*depth[lca(x, y)];}
//求距离

void bfs()
{
    FOR(i, 1, cnt)
    {
        q.push(query[i]);
        dis[query[i]] = 0;
    }
    while(!q.empty())
    {
        int now = q.front(); q.pop();
        for(int i=head[now]; i; i=edge[i].nex)
        {
            int to = edge[i].to;
            if(dis[now] + 1 < dis[to])
            {
                dis[to] = dis[now] + 1;		//更新最短距离
                q.push(to);
            }
        }
    }
}

int main()
{
    n = read();
    m = read();
    nn = sqrt(n);		//分块
    FOR(i, 1, n-1)
    {
        u=read(); v=read();
        add(u, v); add(v, u);
    }
    f[1][0] = 1;
    dfs(1);
    pre();
    while(m--)
    {
        type = read();
        x = read();
        if(type == 1)
        {
            cnt++;
            query[cnt] = x;
            if(cnt == nn)
            {
                bfs();
                cnt = 0;
            }
            continue;
        }
        int ret =  dis[x];
        FOR(i, 1, cnt)
            ret = min(ret, getdis(x, query[i]));		//逐个比较
        printf("%d\n", ret);
    }
    //u = read(); v = read(); printf("lca = %d ; dis = %d\n", lca(u, v), getdis(u, v));
    return 0;
}

/*
5 4
1 2
2 3
2 4
4 5
2 1
2 5
1 2
2 5
*/