时间限制:4000ms
单点时限:2000ms
内存限制:256MB
描述
有一棵树，树上有只毛毛虫。它在这棵树上生活了很久，对它的构造了如指掌。所以它在树上从来都是走最短路，不会绕路。它还还特别喜欢三角形，所以当它在树上爬来爬去的时候总会在想，如果把刚才爬过的那几根树枝/树干锯下来，能不能从中选三根出来拼成一个三角形呢？
输入
输入数据的第一行包含一个整数 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
这个题昨天做的时候总是报RE，也就是运行时错误Runtime Error，原因是它那个测试系统不允许创建多个类，即使是内部类也不行，办法就是改写成数组形式表示。
补充一下：创建多个类是可以的，这里不行可能是堆溢出或则其他问题，希望不要误导了大家。最后结果TLE了，还是要改进一下的。
思路：
1、读取数据，建立图
2、广度优先遍历，找到目的点。这个过程找到的肯定是最短路，因为这是一棵树，两点之间只有一条通路（不重复的情况下）。遍历过程中保存每个点遍历的时候的父亲节点，这样就能够知道走过了哪些节点。
3、遍历任意三条边的组合是否能够组成三角形。
我自己创建了一些测试数据，感觉大数据时应该也还可以，不会超时。只有最后一步看似效率比较低，实际上有的文章说，当边数超过50时，一定能够组成三角形，所以实际上它每次都不会遍历那么多次就返回了。
import java.util.*;
import java.io.*;
/*class MyNode
{
int id;
int flag=0;
List<MyNode> adjacent=null;
MyNode parent=null;
public MyNode(int id)
{
this.id=id;
adjacent=new ArrayList<MyNode>();
}
public void addAdjacnet(MyNode n)
{
this.adjacent.add(n);
}
}*/
public class Main {
int id[];
int flag[];
List<Integer> adjacent[];
int parent[];
public void run()
{
Scanner in = new Scanner(System.in);
int num=in.nextInt();
for(int i=0;i<num;i++)
{
int size=in.nextInt();
id=new int[size];
flag=new int[size];
adjacent=new ArrayList[size];
for(int j=0;j<adjacent.length;j++)
{
adjacent[j]=new ArrayList<Integer>();
}
parent=new int[size];
Map<String,Integer> edges=new HashMap<String,Integer>();
for(int k=0;k<size;k++)
{
id[k]=k+1;
flag[k]=0;
parent[k]=-1;
}
for(int j=0;j<size-1;j++)
{
int start=in.nextInt();
int end=in.nextInt();
int length=in.nextInt();
edges.put(start+" "+end, length);
edges.put(end+" "+start, length);
adjacent[start-1].add(end);
adjacent[end-1].add(start);
}
//System.out.println(nodes);
int queryTimes=in.nextInt();
System.out.println("Case #"+(i+1)+":");
for(int j=0;j<queryTimes;j++)
{
int startNode=in.nextInt();
int endNode=in.nextInt();
String result=find(edges,startNode,endNode);
for(int k=0;k<size;k++)
{
parent[k]=-1;
flag[k]=0;
}
System.out.println(result);
}
}
}
public static void main(String args[]) throws IOException
{
Main m=new Main();
m.run();
}
private String find( Map<String,Integer> edges,
int startNode, int endNode) {
Queue<Integer> queue=new LinkedList<Integer>();
flag[startNode-1]=1;
queue.add(startNode);
while(!queue.isEmpty())
{
int node=queue.poll();
flag[node-1]=2;
if(node==endNode)
{
return judge(node,edges);
}
for(int n:adjacent[node-1])
{
if(flag[n-1]==0)
{
flag[n-1]=1;
parent[n-1]=node;
queue.add(n);
//System.out.println(queue.size());
}
}
}
return "No";
}
private String judge(int node,Map<String,Integer> edges) {
List<Integer> list=new ArrayList<Integer>();
while(parent[node-1]!=-1)
{
Integer length=edges.get(node+" "+parent[node-1]);
if(length==null)
return "No";
list.add(length);
node=parent[node-1];
}
if(list.size()<3)
return "No";
for(int i=0;i<list.size();i++)
{
for(int j=i+1;j<list.size();j++)
{
for(int k=j+1;k<list.size();k++)
{
int temp[]=new int[3];
temp[0]=list.get(i);
temp[1]=list.get(j);
temp[2]=list.get(k);
Arrays.sort(temp);
if(temp[0]+temp[1]>temp[2])
return "Yes";
}
}
}
return "No";
}
}