結果

問題 No.168 ものさし
ユーザー kenkooookenkoooo
提出日時 2015-03-20 01:00:33
言語 Java
(openjdk 23)
結果
AC  
実行時間 603 ms / 2,000 ms
コード長 2,966 bytes
コンパイル時間 2,647 ms
コンパイル使用メモリ 81,276 KB
実行使用メモリ 62,572 KB
最終ジャッジ日時 2024-12-24 07:01:02
合計ジャッジ時間 9,319 ms
ジャッジサーバーID
（参考情報） 		judge2 / judge1
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 266 ms
47,304 KB
testcase_01 AC 56 ms
36,716 KB
testcase_02 AC 57 ms
36,640 KB
testcase_03 AC 58 ms
36,724 KB
testcase_04 AC 56 ms
36,472 KB
testcase_05 AC 56 ms
36,624 KB
testcase_06 AC 57 ms
36,720 KB
testcase_07 AC 58 ms
36,756 KB
testcase_08 AC 56 ms
36,812 KB
testcase_09 AC 66 ms
36,692 KB
testcase_10 AC 98 ms
37,960 KB
testcase_11 AC 243 ms
47,360 KB
testcase_12 AC 486 ms
54,712 KB
testcase_13 AC 565 ms
62,552 KB
testcase_14 AC 542 ms
62,468 KB
testcase_15 AC 57 ms
36,512 KB
testcase_16 AC 64 ms
36,852 KB
testcase_17 AC 78 ms
37,668 KB
testcase_18 AC 130 ms
40,432 KB
testcase_19 AC 563 ms
62,572 KB
testcase_20 AC 576 ms
62,496 KB
testcase_21 AC 603 ms
62,552 KB
testcase_22 AC 590 ms
62,456 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Main {
	public static void main(String[] args) {
		int N = nextInt();
		int[] x = new int[N];
		int[] y = new int[N];
		for (int i = 0; i < N; i++) {
			x[i] = nextInt();
			y[i] = nextInt();
		}
		Kruscal g = new Kruscal(N);
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < i; j++) {
				long dx = x[i] - x[j];
				long dy = y[i] - y[j];
				long distSq = dx * dx + dy * dy;
				long d = (long) Math.sqrt(distSq);
				while (distSq > d * d) {
					d++;
				}

				d = (d + 9) / 10 * 10;
				g.addBidirectionalEdge(i, j, (int) d);
			}
		}
		System.out.println(g.minCost());
	}

	static int nextInt() {
		int c;
		try {
			c = System.in.read();
			while (c != '-' && (c < '0' || c > '9'))
				c = System.in.read();
			if (c == '-')
				return -nextInt();
			int res = 0;
			while (c >= '0' && c <= '9') {
				res = res * 10 + c - '0';
				c = System.in.read();
			}
			return res;
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return -1;
	}
}

class Kruscal {
	int n;
	ArrayList<Edge> graph = new ArrayList<Edge>();

	public Kruscal(int n) {
		this.n = n;
	}

	public void addBidirectionalEdge(int u, int v, int cost) {
		// System.out.println(u + "," + v + "," + cost);
		graph.add(new Edge(cost, u, v));
	}

	public int minCost() {
		Collections.sort(graph);
		// System.out.println(graph);
		UnionFind uf = new UnionFind(n);
		int ans = 0;
		int connected = 1;
		for (int i = 0; i < graph.size(); i++) {
			Edge e = graph.get(i);
			if (!uf.isConnected(e.from, e.to)) {
				uf.union(e.from, e.to);
				connected++;
				ans = Math.max(ans, e.cost);
				if (connected == n) {
					break;
				}
			}
			if (uf.isConnected(0, n - 1)) {
				return ans;
			}
		}
		return ans;
	}

	static class Edge implements Comparable<Edge> {
		int cost;
		int from;
		int to;

		public Edge(int cost, int from, int to) {
			this.cost = cost;
			this.from = from;
			this.to = to;
		}

		@Override
		public int compareTo(Edge o) {
			if (this.cost == o.cost) {
				return 0;
			} else if (this.cost > o.cost) {
				return 1;
			} else {
				return -1;
			}
		}

		public String toString() {
			return this.cost + "," + this.from + "," + this.to;
		}
	}

	static class UnionFind {
		private int[] data;

		public UnionFind(int size) {
			data = new int[size];
			Arrays.fill(data, -1);
		}

		public void union(int x, int y) {
			x = root(x);
			y = root(y);
			if (x != y) {
				if (data[y] < data[x]) {
					int tmp = y;
					y = x;
					x = tmp;
				}
				data[x] += data[y];
				data[y] = x;
			}
		}

		public boolean isConnected(int x, int y) {
			return root(x) == root(y);
		}

		private int root(int x) {
			return data[x] < 0 ? x : (data[x] = root(data[x]));
		}

		public int size(int x) {
			return -data[root(x)];
		}

		public String toString() {
			return Arrays.toString(data);
		}
	}
}
0