第十三届蓝桥杯国赛试题H：机房

试题 H: 机房

【问题描述】
这天，小明在机房学习。
他发现机房里一共有 n 台电脑，编号为 1 到 n，电脑和电脑之间有网线连
接，一共有 n − 1 根网线将 n 台电脑连接起来使得任意两台电脑都直接或者间接地相连。
小明发现每台电脑转发、发送或者接受信息需要的时间取决于这台电脑和多少台电脑直接相连, 而信息在网线中的传播时间可以忽略。比如如果某台电脑用网线直接连接了另外 d 台电脑，那么任何经过这台电脑的信息都会延迟 d 单位时间 (发送方和接收方也会产生这样的延迟，当然如果发送方和接收方都是同一台电脑就只会产生一次延迟)。
小明一共产生了 m 个疑问：如果电脑 ui 向电脑 vi 发送信息，那么信息从ui 传到 vi 的最短时间是多少？
【输入格式】
输入共 n + m 行，第一行为两个正整数 n, m。
后面 n − 1 行，每行两个正整数 x, y 表示编号为 x 和 y 的两台电脑用网线直接相连。
后面 m 行，每行两个正整数 ui, vi 表示小明的第 i 个疑问。
【输出格式】
输出共 m 行，第 i 行一个正整数表示小明第 i 个疑问的答案。
【样例输入】
4 3
1 2
1 3
2 4
2 3
3 4
3 3
【样例输出】
5
6
1
【样例说明】
这四台电脑各自的延迟分别为 2, 2, 1, 1。
对于第一个询问，从 2 到 3 需要经过 2, 1, 3，所以时间和为 2 + 2 + 1 = 5。
对于第二个询问，从 3 到 4 需要经过 3, 1, 2, 4，所以时间和为 1+2+2+1 = 6。
对于第三个询问，从 3 到 3 只会产生一次延迟，所以时间为 1。
【评测用例规模与约定】
对于 30% 的数据，保证 n, m ≤ 1000；
对于 100% 的数据，保证 n, m ≤ 100000 。

LCA+树形DP

暴力深搜m次超时，所以用LCA算法，并用DP表示节点到根节点距离

核心部分

初始化dfs（cur，pre），记录当前节点，父节点

dep数组记录当前节点深度

    dep[cur]=dep[pre]+1;

dp数组记录当前节点到根节点距离
    dp[cur]=dp[pre]+v[cur].size();

fa[cur][i]数组记录当前节点cur向上爬（1<<i）个节点所能达到的节点

        初始化  fa[cur][0]=pre;  cur节点向上爬（1<<0）,即一个单位，父节点

        分析向上爬（1<<i）位，即2^i，2^i=2^(i-1)+2^(i-1)，由此可递推出fa数组所能向上爬到的最高节点，递推公式fa[cur][i]=fa[fa[cur][i-1]][i-1];

模板LCA

        要找两个节点x，y最近公共祖先，首先将两节点中深度大的向上爬至rot处和另一个节点y同一深度，即dep[rot]==dep[y]

        1，rot==y，return rot；

        2，rot！=y，此时两节点处于同一层，要找两个最近公共祖先，

                方法1：可让两节点同时向上爬，知道第一个祖先为统一节点就可以了，但是这样和暴力一样了，所以，要用其他方法

                方法2：被增法，两节点尽可能往上爬，从大到小，当两点所爬到节点相同，节点不动，找更小可以爬到得到位置去爬，当两节点所爬到位置不同，两节点向上爬；最终两节点所爬到的位置的父元素，即为节点x，y的最近公共最近节点，实践复杂度log（n），代码如下

for(int i=20;i>=0;i--){
        if(fa[rot][i]!=fa[y][i]){
            rot=fa[rot][i],y=fa[y][i];
        }
    }

模板UP

        UP（x，d） 即x节点向上爬d个节点所到达的节点

        方法一：一次一次爬，时间复杂度log（n）<=t<=n，最坏情况，相当与暴力（不用）

        方法二：将d看为二进制，例如5=101，即向上爬2^0和2^2，时间复杂度为log（方法一），最坏log（n），不会超时，

for(int i=0;(1<<i)<=d;i++){
        if((1<<i)&d!=0){
            res=fa[res][i];
        }
    }

全部代码如下：全网最短最精简

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+3;
int n,m;
vector<int> v[maxn];
int dep[maxn],dp[maxn];
int fa[maxn][20];
void dfs(int cur,int pre){
	dep[cur]=dep[pre]+1;
	dp[cur]=dp[pre]+v[cur].size();
	fa[cur][0]=pre;
	for(int i=1;(i<<i)<=dep[cur];i++){
		fa[cur][i]=fa[fa[cur][i-1]][i-1];
	}
	for(auto son:v[cur]){
		if(son!=pre){
			dfs(son,cur);
		}
	}
}
int UP(int x,int d){
	int res=x;
	for(int i=0;(1<<i)<=d;i++){
		if((1<<i)&d!=0){
			res=fa[res][i];
		}
	}
	return res;
}
int LCA(int x,int y){
	if(dep[x]<dep[y]) swap(x,y);
	int rot=UP(x,dep[x]-dep[y]);
	if(rot==y)return rot;
	for(int i=20;i>=0;i--){
		if(fa[rot][i]!=fa[y][i]){
			rot=fa[rot][i],y=fa[y][i];
		}
	}
}
int main(){
	cin>>n>>m;
	for(int i=1;i<n;i++){
		int x,y;
		cin>>x>>y;
		v[x].push_back(y);
		v[y].push_back(x);
	}
	dfs(1,0);
	while(m--){
		int x,y;
		cin>>x>>y;
		int d=LCA(x,y);
		cout<<dp[x]+dp[y]-dp[d]-dp[fa[d][0]]<<endl;
	}
	
	return 0;
}