結果

問題 No.168 ものさし
ユーザー kenkooookenkoooo
提出日時 2015-03-20 00:43:10
言語 Java21
(openjdk 21)
結果
AC  
実行時間 662 ms / 2,000 ms
コード長 3,135 bytes
コンパイル時間 3,519 ms
コンパイル使用メモリ 86,908 KB
実行使用メモリ 74,204 KB
最終ジャッジ日時 2023-08-25 20:46:30
合計ジャッジ時間 10,193 ms
ジャッジサーバーID
（参考情報） 		judge15 / judge12
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 269 ms
59,432 KB
testcase_01 AC 43 ms
49,264 KB
testcase_02 AC 43 ms
49,636 KB
testcase_03 AC 42 ms
49,308 KB
testcase_04 AC 43 ms
49,324 KB
testcase_05 AC 43 ms
49,368 KB
testcase_06 AC 43 ms
49,508 KB
testcase_07 AC 42 ms
49,360 KB
testcase_08 AC 43 ms
49,420 KB
testcase_09 AC 60 ms
50,288 KB
testcase_10 AC 100 ms
53,288 KB
testcase_11 AC 246 ms
59,268 KB
testcase_12 AC 464 ms
66,360 KB
testcase_13 AC 533 ms
73,680 KB
testcase_14 AC 527 ms
73,948 KB
testcase_15 AC 42 ms
49,328 KB
testcase_16 AC 55 ms
50,164 KB
testcase_17 AC 72 ms
50,680 KB
testcase_18 AC 119 ms
54,184 KB
testcase_19 AC 649 ms
73,784 KB
testcase_20 AC 606 ms
73,196 KB
testcase_21 AC 643 ms
73,532 KB
testcase_22 AC 662 ms
74,204 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 = (sqrtCeil(distSq) + 9) / 10 * 10;
				g.addBidirectionalEdge(i, j, (int) d);
			}
		}
		System.out.println(g.minCost());
	}

	static long sqrtCeil(long n) {
		long l = 0;
		long r = 2000000000;
		while (l + 1 < r) {
			// (l+r)/2を超えない整数
			long c = (l + r) >>> 1;
			if (c * c >= n) {
				r = c;
			} else {
				l = c;
			}
		}
		return r;
	}

	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