tmk找三角

Description

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

Input

第一行输入一个T，表示有多少组样例。

对于每组数据：第一行包含一个整数 N，表示树上节点的个数（从 1 到 N 标号）。

接下来的 N-1 行包含三个整数 a, b, len，表示有一根长度为 len 的树枝/树干在节点 a 和节点 b 之间。

接下来一行包含一个整数 M，表示询问数。

接下来M行每行两个整数 S, T，表示毛毛虫从 S 爬行到了 T，询问这段路程中的树枝/树干是否能拼成三角形。

Output

对于每组数据,每个询问输出一行，包含"Yes"或“No”，表示是否可以拼成三角形。

Sample Input

251 2 51 3 202 4 304 5 1523 43 551 4 322 3 1003 5 454 5 6021 41 3

Sample Output

NoYesNoYes

HINT

对于20%数据 1 ≤ N, M ≤ 1000

对于所有数据 1 ≤ N ≤ 100000, 1 ≤ M ≤ 100000, 1 ≤ len ≤ 1000000000

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<cmath>
using namespace std;
vector<int>v;
const int D=100000+10;
const int E=2*D;
struct Edge{
int u;
int v;
int l;
} e[E];
int next1[E];
int root[D];
int vis[D]={0};
int dist[D]={0};
void dfs(int u){
int p=root[u];
while(p>=0){
    if(!vis[e[p].v]){
        vis[e[p].v]=1;
        dist[e[p].v]=dist[u]+1;
        dfs(e[p].v);
    }
    p=next1[p];
}
}
int fa[D];
int getpath(int s,int t){
   if(s==t){
    return 1;
   }
   int p=root[s];
   while(p>=0){
    if(!vis[e[p].v]){
       vis[e[p].v]=1;
       fa[e[p].v]=p;
       if(getpath(e[p].v,t))return 1;;
    }
    p=next1[p];
   }
   return 0;
}
int main(){
int T;
cin>>T;
while(T--){
    memset(root,-1,sizeof(root));
    int n;
    cin>>n;
    int cnt=0;
    for(int i=0;i<n-1;i++){
        int a,b,c;
       cin>>a>>b>>c;
       next1[cnt]=root[a];
       root[a]=cnt;
       e[cnt].u=a;
       e[cnt].v=b;
       e[cnt++].l=c;
       next1[cnt]=root[b];
       root[b]=cnt;
       e[cnt].u=b;
       e[cnt].v=a;
       e[cnt++].l=c;
    }
    dfs(1);
    int m;
    cin>>m;
    for(int i=0;i<m;i++){
        memset(fa,-1,sizeof(fa));
        int s,t;
        cin>>s>>t;
       if(abs(dist[s]-dist[t])>=45){cout<<"Yes"<<endl;continue;}
       memset(vis,0,sizeof(vis));
       vis[s]=1;
       getpath(s,t);
       int p=fa[t];
       v.clear();
       while(p>=0){
        //cout<<p<<endl;
        v.push_back(e[p].l);
        p=fa[e[p].u];
       }
       sort(v.begin(),v.end());
       int h,j,k;
       int flag=0;
       for(h=0;h<v.size();h++){
        for(j=h+1;j<v.size();j++){
            for(k=j+1;k<v.size();k++){
                if(v[h]+v[j]>v[k]){flag=1;break;}
            }
            if(flag)break;
        }
        if(flag)break;
       }
       if(flag)cout<<"Yes"<<endl;
       else cout<<"No"<<endl;
    }
}
return 0;}

几个要点

如果一组边不能组成形成三角形，那么这三边属于斐波那契额数列，而斐波那契数列递增，从第45项开始超过十亿，也就是说最短路径边数超过44，必能组成三角形

打表记录每个点到点1的距离，可以dfs与bfs，都是遍历每个点，时间开销一样，任意两点之间最短路径就是两个点到点1的距离差（可反证），这样两点距离超过45就不用去搜索他们之间的路径了。

小于45的路径，用dfs搜索路径，bfs会遍历最多45层的点。

一开始，我是考虑边权的但一直wa，这题，迷。

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
vector<int>v;
const int D=100000+10;
const int E=2*D;
const int INF=999999999;
struct Edge{
int u;
int v;
int l;
} e[E];
int next1[E];
int root[E];
int vis[D]={0};
int min1=INF;
int sum=0;
int fa[E];
int ans[E];
int ll=0,al;
void dfs(int x,int y){
if(x==y){
    if(sum<min1){
       min1=sum;
       memcpy(ans,fa,sizeof(fa));
       al=ll;
    }
    return ;
}
int p=root[x];
while(p>=0){
    sum+=e[p].l;
    if(vis[e[p].v]||sum>min1){sum-=e[p].l;p=next1[p];continue;}
    vis[e[p].v]=1;
    fa[e[p].v]=p;
    ll++;
    dfs(e[p].v,y);
    ll--;
    fa[e[p].v]=-1;
    vis[e[p].v]=0;
    sum-=e[p].l;
    p=next1[p];
}
}

int main(){
int t;
cin>>t;
while(t--){
    memset(root,-1,sizeof(root));
    memset(next1,-1,sizeof(next1));
    int n;
    cin>>n;
    int cnt=0;
    for(int i=0;i<n-1;i++){
        int a,b,c;
       cin>>a>>b>>c;
       next1[cnt]=root[a];
       root[a]=cnt;
       e[cnt].u=a;
       e[cnt].v=b;
       e[cnt++].l=c;
       next1[cnt]=root[b];
       root[b]=cnt;
       e[cnt].u=b;
       e[cnt].v=a;
       e[cnt++].l=c;
    }
    int m;
    cin>>m;
    for(int i=0;i<m;i++){
        min1=INF;
        memset(fa,-1,sizeof(fa));
        int s,t;
        cin>>s>>t;
        vis[s]=1;
        dfs(s,t);
        vis[s]=0;
       if(al>45){cout<<"Yes"<<endl;continue;}
       int p=ans[t];
       v.clear();
       while(p>=0){
        //cout<<p<<endl;
        v.push_back(e[p].l);
        p=ans[e[p].u];
       }
       sort(v.begin(),v.end());
       int h,j,k;
       int flag=0;
       for(h=0;h<v.size();h++){
        for(j=h+1;j<v.size();j++){
            for(k=j+1;k<v.size();k++){
                if(v[h]+v[j]>v[k]){flag=1;break;}
            }
            if(flag)break;
        }
        if(flag)break;
       }
       if(flag)cout<<"Yes"<<endl;
       else cout<<"No"<<endl;
    }
}
return 0;}