hdoj 5934 强连通分量+缩点 模版题（Java版）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5934
题目大意就是：
告诉你n个烟花，然后燃放每个烟花有它的花费，每个燃放的烟花有它自身影响范围，在这个范围内的其他烟花会自动被燃放，就不用花钱。问你燃放所有的烟花的最小花费是多少。
这明显是一个强连通分量的题，只要你枚举每个烟花和其他烟花之间的距离然后比较该烟花的影响范围是否大于距离，大于的话就连一条边从这个烟花到另一个烟花。
注意题目给的数据范围，算烟花之间的范围时，因为平方的关系，会超出int的范围，所以要用long存储那里。
我刚开始就wa了好几次因为这个原因，看了讨论才发现问题。。

AC代码：

import java.util.Arrays;
import java.util.Scanner;
import java.util.Stack;

public class Main {
	static class edge{
		int v,next;
		edge(int v,int next){
			this.v=v;
			this.next=next;
		}
	}
	static class point{
		int x,y,r,c;
		point(int x,int y,int r,int c){
			this.x=x;
			this.y=y;
			this.r=r;
			this.c=c;
		}
	}
	static point pt[]=new point[1005];
	static edge e[]=new edge[1000005];
	static int p[]=new int[1005];
	static int dfn[]=new int[1005];
	static int low[]=new int[1005];
	static boolean inStack[]=new boolean[1005];
	static int belong[]=new int[1005];
	static int in[]=new int[1005];
	static Stack<Integer> s=new Stack<Integer>();
	static int n,scc,eid,idx;
	static void init(){
		scc=eid=idx=0;
		Arrays.fill(p, -1);
		Arrays.fill(dfn, 0);
		Arrays.fill(low, 0);
		Arrays.fill(inStack, false);
		Arrays.fill(in, 0);
	}
	static void insert(int u,int v){
		e[eid]=new edge(v,p[u]);
		p[u]=eid++;
	}
	static void targan(int u){
		low[u]=dfn[u]=++idx;
		s.push(u);
		inStack[u]=true;
		int j;
		for(int i=p[u];i!=-1;i=e[i].next){
			int v=e[i].v;
			if(dfn[v]==0){
				targan(v);
				low[u]=Math.min(low[u], low[v]);
			}else if(inStack[v]){
				low[u]=Math.min(low[u], dfn[v]);
			}
		}
		if(dfn[u]==low[u]){
			scc++;
			do{
				j=s.pop();
				inStack[j]=false;
				belong[j]=scc;
			}while(u!=j);
		}
	}
	
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int t=sc.nextInt();
		for(int i=1;i<=t;i++){
			int n=sc.nextInt();
			init();
			int x,y,r,c;
			for(int j=0;j<n;j++){
				x=sc.nextInt();
				y=sc.nextInt();
				r=sc.nextInt();
				c=sc.nextInt();
				pt[j]=new point(x,y,r,c);
			}
			for(int j=0;j<n;j++){
				for(int k=j+1;k<n;k++){
				//注意这里
					long dis=(long)(pt[j].x-pt[k].x)*(pt[j].x-pt[k].x)+(long)(pt[j].y-pt[k].y)*(pt[j].y-pt[k].y);
					if(dis<=(long)pt[j].r*pt[j].r){   //注意这里要用long
						insert(j,k);
					}
					if(dis<=(long)pt[k].r*pt[k].r){    //还有这里
						insert(k,j);
					}
				}
			}
			for(int j=0;j<n;j++){
				if(dfn[j]==0){
					targan(j);
				}
			}
			for(int j=0;j<n;j++){
				for(int k=p[j];k!=-1;k=e[k].next){
					int v=e[k].v;
					if(belong[j]!=belong[v]){
						in[belong[v]]++;
					}
				}
			}
			int sum=0;
			for(int j=1;j<=scc;j++){
				if(in[j]==0){
					int min=0x3f3f3f3f;
					for(int k=0;k<n;k++){
						if(belong[k]==j){
							min=Math.min(min, pt[k].c);
						}
					}
					sum+=min;
				}
			}
			System.out.println("Case #"+i+": "+sum);
		}
		sc.close();
	}
}