11631 - Dark roads. WA!!!
Posted: Tue Dec 25, 2012 8:42 pm
Hi,
I believe I chose right approach, but I got WA,
Could anybody help with advice or provide some input
I believe I chose right approach, but I got WA,
Could anybody help with advice or provide some input
Code: Select all
import java.io.*;
import java.util.Arrays;
import java.util.Scanner;
class Main {
public static void main(String[] args) {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
try {
Scanner scanner = new Scanner(reader);
while (scanner.hasNextInt()) {
int m = scanner.nextInt();
int n = scanner.nextInt();
Distance[] distances = new Distance[n];
int sum = 0;
for (int i = 0; i < n; i++) {
int from = scanner.nextInt();
int to = scanner.nextInt();
int distance = scanner.nextInt();
distances[i] = new Distance(from, to, distance);
sum += distance;
}
WeightedQuickUnion quickUnion = new WeightedQuickUnion(m + 1);
Arrays.sort(distances);
int totalDistance = 0;
for (Distance distance : distances) {
if (quickUnion.find(distance.from, distance.to)) {
continue;
}
totalDistance += distance.distance;
quickUnion.union(distance.from, distance.to);
}
writer.write((sum-totalDistance) + "\n");
}
writer.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
static class Distance implements Comparable<Distance> {
int from, to, distance;
Distance(int from, int to, int distance) {
this.from = from;
this.to = to;
this.distance = distance;
}
@Override
public int compareTo(Distance o) {
int distanceDiff = distance - o.distance;
if (distanceDiff != 0) {
return distanceDiff;
}
int fromDiff = from - o.from;
if (fromDiff != 0) {
return fromDiff;
}
return to - o.to;
}
}
static class QuickUnion extends FindUnion {
public QuickUnion(int n) {
super(n);
}
@Override
public void union(int p, int q) {
int i = getRoot(p);
int j = getRoot(q);
array[i] = j;
groups--;
}
@Override
public boolean find(int a, int b) {
return getRoot(a) == getRoot(b);
}
protected int getRoot(int a) {
if (a == array[a]) {
return a;
}
return getRoot(array[a]);
}
}
static abstract class FindUnion {
protected final int[] array;
protected int groups;
protected FindUnion(int n) {
this.array = new int[n];
for (int i = 1; i < array.length; i++) {
array[i] = i;
}
groups = n;
}
public abstract void union(int p, int q);
public abstract boolean find(int p, int q);
public int getGroups() {
return groups;
}
}
static class WeightedQuickUnion extends QuickUnion {
final int[] size;
public WeightedQuickUnion(int n) {
super(n);
size = new int[n];
for (int i = 0; i < size.length; i++) {
size[i] = 1;
}
}
@Override
public void union(int p, int q) {
int i = getRoot(p);
int j = getRoot(q);
if (size[i] < size[j]) {
array[i] = j;
size[j] += size[i];
} else {
array[j] = i;
size[i] += size[j];
}
groups--;
}
}
}