练习 树上的三角形

描述

有一棵树，树上有只毛毛虫。它在这棵树上生活了很久，对它的构造了如指掌。所以它在树上从来都是走最短路，不会绕路。它还还特别喜欢三角形，所以当它在树上爬来爬去的时候总会在想，如果把刚才爬过的那几根树枝/树干锯下来，能不能从中选三根出来拼成一个三角形呢？

输入

输入数据的第一行包含一个整数 T，表示数据组数。
接下来有 T 组数据，每组数据中：
第一行包含一个整数 N，表示树上节点的个数（从 1 到 N 标号）。
接下来的 N-1 行包含三个整数 a, b, len，表示有一根长度为 len 的树枝/树干在节点 a 和节点 b 之间。
接下来一行包含一个整数 M，表示询问数。
接下来M行每行两个整数 S, T，表示毛毛虫从 S 爬行到了 T，询问这段路程中的树枝/树干是否能拼成三角形。

1 ≤ T ≤ 5
小数据：1 ≤ N ≤ 100, 1 ≤ M ≤ 100, 1 ≤ len ≤ 10000
大数据：1 ≤ N ≤ 100000, 1 ≤ M ≤ 100000, 1 ≤ len ≤ 1000000000

输出

对于每组数据，先输出一行"Case #X:",其中X为数据组数编号，从 1 开始。
接下来对于每个询问输出一行，包含"Yes"或“No”，表示是否可以拼成三角形。

样例输入

2
5
1 2 5
1 3 20
2 4 30
4 5 15
2
3 4
3 5
5
1 4 32
2 3 100
3 5 45
4 5 60
2
1 4
1 3

样例输出

Case #1:
No
Yes
Case #2:
No
Yes

这个题目就不是图啊，题目中说走最短路，不会绕路  则不会有环出现，这是一个森林的求最短路径的问题。不，这是树，所有路径都是连通的树。。。

所以，全部理解错误。这个树的起点一定是1，然后较大的点一定在同层或下一层，较小的点则相反。

所以很多时候，能够完全了解问题最重要的部分是很重要的。就像是自己写程序时，永远知道自己想要什么样的结果又有什么样的输入，不会在这一块被迷惑。

int deep[100000];//深度
int branch[100000][2];//分支,数组下标表示子节点序号，第一个数据为父节点，之后为权值
int path[50],pn;//路径
vector<int> p[100000];//所有节点与对应的子节点和路径长度
void DFS(int father,int x,int d){
	deep[x] = d;
	for( int i=0;i<p[x].size();i+=2){
		if(p[x][i] == father)continue;
			branch[p[x][i]][0] = x; 
			branch[p[x][i]][1] = p[x][i+1];
			DFS( x,p[x][i] , d+1);
		
	}
}
void childToF(int &a,int &b){//从
	while(deep[a] > deep[b]){
		path[pn++] = branch[a][1];
		a = branch[a][0];
		if(pn == 50)return;
	}
}

void getBranch(int a,int b){//从a到b获得树枝数量
	pn=0;
	if(deep[a]<deep[b])childToF(b,a);
	else childToF(a,b);
	if(pn == 50)return;//当为50时，一定为yes
	while(a != b){
		path[pn++] = branch[a][1];//当为同一层时，同时寻找父节点，直到相交
		a = branch[a][0];
		path[pn++] = branch[b][1];
		b = branch[b][0];
		if(pn > 49)return ;
	}
}
int main(){
	int T = 0;
	int N = 0;
	int M = 0;
	int a = 0;
	int b = 0;
	int len = 0;
	int NO=1;
	cin>>T;
	while(T--){
		cin>>N;
		N--;
		while(N--){
			cin>>a>>b>>len;
			p[a].push_back(b);
			p[a].push_back(len);
			p[b].push_back (a);
			p[b].push_back (len);
		}
		DFS(1,1,1);//根节点深度为1
		cin>>M;
		printf("Case #%d:\n",NO++);	
		while(M--){
			cin>>a>>b;
			getBranch(a,b);					
			if(pn > 49|| pn < 3)cout<<"No\n";
			else{
				sort(path,path+pn);
				for(a = 0; a < pn-2;a++){
					if(path[a] + path[a+1] > path[a+2])break;
				}
			if(pn > 49)cout<<"No\n";
			else cout<<"Yes\n";
			}
			
		}
	}
	return 0;
}

别人的代码：

#include <stdio.h>
#include <vector>
#include <algorithm>
using namespace std;
int deep[100010], f[100010][2];
vector<int> e[100010];
int c[60], cn;
void dfs(int fa, int x, int d){
    int i, y;
    deep[x] = d;
    for (i = 0; i < (int)e[x].size(); i += 2){
        y = e[x][i];
        if (y == fa) continue;
        f[y][0] = x;
        f[y][1] = e[x][i + 1];
        dfs(x, y, d + 1);
    }
}
void pd(int x, int y){
    while (deep[x] > deep[y]){
        c[cn++] = f[x][1];
        x = f[x][0];
        if (cn == 50) return;
    }
    while (deep[y] > deep[x]){
        c[cn++] = f[y][1];
        y = f[y][0];
        if (cn == 50) return;
    }
    while (x != y){
        c[cn++] = f[x][1];
        x = f[x][0];
        c[cn++] = f[y][1];
        y = f[y][0];
        if (cn >= 50) return;
    }
}
int main(){
    int T, ri = 1, n, m, x, y, z, i;
    scanf("%d", &T);
    while (T--){
        scanf("%d", &n);
        for (i = 1; i <= n; i++) e[i].clear();
        for (i = 1; i < n; i++){
            scanf("%d%d%d", &x, &y, &z);
            e[x].push_back(y);
            e[x].push_back(z);
            e[y].push_back(x);
            e[y].push_back(z);
        }
        dfs(0, 1, 0);
        printf("Case #%d:\n", ri++);
        scanf("%d", &m);
        while (m--){
            scanf("%d%d", &x, &y);
            cn = 0;
            pd(x, y);
            sort(c, c + cn);
            for (i = 0; i + 2 < cn; i++){
                if (c[i] + c[i + 1] > c[i + 2]) break;
            }
            if (i + 2 < cn) printf("Yes\n");
            else printf("No\n");
        }
    }
    return 0;
}