POJ2349最小生成树

最小生成树中第S长的边是使得联通分支数<=S的最小的D。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;

public class Main {
	public static void main(String[] args) {
		new POJ2349().solve();
	}
}

class POJ2349 {

	InputReader in = new InputReader(System.in);
	PrintWriter out = new PrintWriter(System.out);
	double[] x , y ;
	int[] father ;
	List<Edge> edges ; 
	int S , P ;
	
	double dist(int i , int j){
		return Math.sqrt((x[i]-x[j])*(x[i]-x[j]) + (y[i]-y[j])*(y[i]-y[j])) ;
	}
	
	int getFather(int u){
		return u == father[u] ? u : getFather(father[u]) ;
	}
	
	boolean canUnion(int u , int v){
		int fu = getFather(u) ;
		int fv = getFather(v) ;
		if(fu == fv) return false ;
		father[fu] = fv ;
		return true ;
	}
	
	double kruskal(){
        double res = 0 ;
		father = new int[P] ;
		for(int i = 0 ; i < P ; i++) father[i] = i ;
		int size = 0 ;
	    Collections.sort(edges) ;
	    for(Edge e : edges){
	    	if(canUnion(e.start , e.end)){
	    		e.used = true ;
	    		if(++size >= P) break ;
	    	}
	    }
	    Collections.reverse(edges) ;
	    for(Edge e : edges){
	    	if(e.used){
	    		if(--S == 0){
	    			res = e.length ;
	    		    break ;
	    		}
	    	}
	    }
	    
	    return res ; 
	}

	void solve() {
		int t = in.nextInt()   ;
		while(t-- > 0){
			S = in.nextInt() ;
			P = in.nextInt() ;
			x = new double[P] ;
			y = new double[P] ;
			for(int i = 0 ; i < P ; i++){
				x[i] = in.nextDouble() ;
			    y[i] = in.nextDouble() ;
			}
		    edges = new ArrayList<Edge>() ;
			for(int i = 0 ; i < P ; i++){
				for(int j = 0 ; j < i ; j++){
					edges.add(new Edge(i, j, dist(i,j) ) ) ;
				}
			}
			out.printf("%.2f\n" , kruskal() );
		}

		out.flush();
	}
	
	class Edge implements Comparable<Edge>{
		int start ;
		int end ;
		double length ;
		boolean used ;
		Edge(int start , int end , double length){
			this.start = start ;
			this.end = end ;
			this.length = length ;
			used = false ;
		}
		@Override
		public int compareTo(Edge other) {
			return Double.compare(length , other.length) ;
		}
	}

}

class InputReader {
	public BufferedReader reader;
	public StringTokenizer tokenizer;

	public InputReader(InputStream stream) {
		reader = new BufferedReader(new InputStreamReader(stream), 32768);
		tokenizer = null;
	}

	public String next() {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new StringTokenizer(reader.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken();
	}

	public int nextInt() {
		return Integer.parseInt(next());
	}

	public long nextLong() {
		return Long.parseLong(next());
	}

	public double nextDouble() {
		return Double.parseDouble(next());
	}

}