[Java]数据分析--聚类

距离度量

• 需求：计算两点间的欧几里得距离、曼哈顿距离、切比雪夫距离、堪培拉距离
• 实现：利用commons.math3库相应函数

import org.apache.commons.math3.ml.distance.*;

public class TestMetrics {
    public static void main(String[] args) {
        double[] x = {1, 3}, y = {5, 6};
        
        EuclideanDistance eD = new EuclideanDistance();
        System.out.printf("Euclidean distance = %.2f%n", eD.compute(x,y));
        
        ManhattanDistance mD = new ManhattanDistance();
        System.out.printf("Manhattan distance = %.2f%n", mD.compute(x,y));
        
        ChebyshevDistance cD = new ChebyshevDistance();
        System.out.printf("Chebyshev distance = %.2f%n", cD.compute(x,y));
        
        CanberraDistance caD = new CanberraDistance();
        System.out.printf("Canberra distance =  %.2f%n", caD.compute(x,y));
    }
}

Euclidean distance = 5.00
Manhattan distance = 7.00
Chebyshev distance = 4.00
Canberra distance = 1.00

层次聚类

• 需求：将13个样本点分为3类
• 实现：m点划分为k类，先令m点的每个点为一类，然后找到中心最近的两个类，用一个新的聚类替换，重复m-k次

HierachicalClustering.java

import java.util.HashSet;

public class HierarchicalClustering {
    private static final double[][] DATA = {{1,1}, {1,3}, {1,5}, {2,6}, {3,2}, 
        {3,4}, {4,3}, {5,6}, {6,3}, {6,4}, {7,1}, {7,5}, {7,6}};
    private static final int M = DATA.length;  // number of points
    private static final int K = 3;            // number of clusters

    public static void main(String[] args) {
        HashSet<Cluster> clusters = load(DATA);
        for (int i = 0; i < M - K; i++) {
            System.out.printf("%n%2d clusters:%n", M-i-1);
            coalesce(clusters);
            System.out.println(clusters);
        }
    }
    
    private static HashSet<Cluster> load(double[][] data) {
        HashSet<Cluster> clusters = new HashSet();
        for (double[] datum : DATA) {
            clusters.add(new Cluster(datum[0], datum[1]));
        }
        return clusters;
    } 
    
    private static void coalesce(HashSet<Cluster> clusters) {
        Cluster cluster1=null, cluster2=null;
        double minDist = Double.POSITIVE_INFINITY;
        for (Cluster c1 : clusters) {
            for (Cluster c2 : clusters) {
                if (!c1.equals(c2) && Cluster.distance(c1, c2) < minDist) {
                    cluster1 = c1;
                    cluster2 = c2;
                    minDist = Cluster.distance(c1, c2);
                }
            }
        }
        clusters.remove(cluster1);
        clusters.remove(cluster2);
        clusters.add(Cluster.union(cluster1, cluster2));
    }
}

Point.java

public class Point {
    private final double x, y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }

    @Override
    public int hashCode() {
        int xhC = new Double(x).hashCode();
        int yhC = new Double(y).hashCode();
        return (int)(xhC + 79*yhC);
    }

    @Override
    public boolean equals(Object object) {
        if (object == null) {
            return false;
        } else if (object == this) {
            return true;
        } else if (!(object instanceof Point)) {
            return false;
        }
        Point that = (Point)object;
        return bits(that.x) == bits(this.x) && bits(that.y) == bits(this.y);
    }
    
    private long bits(double d) {
        return Double.doubleToLongBits(d);

    }

    @Override
    public String toString() {
        return String.format("(%.2f,%.2f)", x,y);
    }
}

Cluster.java

import java.util.HashSet;

public class Cluster {
    private final HashSet<Point> points;
    private Point centroid;

    public Cluster(HashSet points, Point centroid) {
        this.points = points;
        this.centroid = centroid;
    }
    
    public Cluster(Point point) {
        this.points = new HashSet();
        this.points.add(point);
        this.centroid = point;
    }

    public Cluster(double x, double y) {
        this(new Point(x,y));
    }

    public Point getCentroid() {
        return centroid;
    }

    public void add(Point point) {
        points.add(point);
        recomputeCentroid();
    }

    public void recomputeCentroid() {
        double xSum=0.0, ySum=0.0;
        for (Point point : points) {
            xSum += point.getX();
            ySum += point.getY();
        }
        centroid = new Point(xSum/points.size(), ySum/points.size());
    }
    
    public static double distance(Cluster c1, Cluster c2) {
        double dx = c1.centroid.getX() - c2.centroid.getX();
        double dy = c1.centroid.getY() - c2.centroid.getY();
        return Math.sqrt(dx*dx + dy*dy);
    }
    
    public static Cluster union(Cluster c1, Cluster c2) {
        Cluster cluster = new Cluster(c1.points, c1.centroid);
        cluster.points.addAll(c2.points);
        cluster.recomputeCentroid();
        return cluster;
    }

    @Override
    public int hashCode() {
        return points.hashCode();
    }

    @Override
    public boolean equals(Object object) {
        if (object == null) {
            return false;
        } else if (object == this) {
            return true;
        } else if (!(object instanceof Cluster)) {
            return false;
        }
        final Cluster that = (Cluster)object;
        return that.points.equals(this.points);
    }

    @Override
    public String toString() {
        return String.format("%n{%s,%s}", centroid, points);
    }
}

结果-->

12 clusters:
[
{(1.00,1.00),[(1.00,1.00)]}, 
{(1.00,3.00),[(1.00,3.00)]}, 
{(2.00,6.00),[(2.00,6.00)]}, 
{(3.00,2.00),[(3.00,2.00)]}, 
{(4.00,3.00),[(4.00,3.00)]}, 
{(6.00,4.00),[(6.00,4.00)]}, 
{(7.00,1.00),[(7.00,1.00)]}, 
{(7.00,5.50),[(7.00,6.00), (7.00,5.00)]}, 
{(6.00,3.00),[(6.00,3.00)]}, 
{(3.00,4.00),[(3.00,4.00)]}, 
{(1.00,5.00),[(1.00,5.00)]}, 
{(5.00,6.00),[(5.00,6.00)]}]

11 clusters:
[
{(1.00,1.00),[(1.00,1.00)]}, 
{(1.00,3.00),[(1.00,3.00)]}, 
{(2.00,6.00),[(2.00,6.00)]}, 
{(3.00,2.00),[(3.00,2.00)]}, 
{(4.00,3.00),[(4.00,3.00)]}, 
{(7.00,1.00),[(7.00,1.00)]}, 
{(7.00,5.50),[(7.00,6.00), (7.00,5.00)]}, 
{(3.00,4.00),[(3.00,4.00)]}, 
{(6.00,3.50),[(6.00,3.00), (6.00,4.00)]}, 
{(1.00,5.00),[(1.00,5.00)]}, 
{(5.00,6.00),[(5.00,6.00)]}]

10 clusters:
[
{(1.00,1.00),[(1.00,1.00)]}, 
{(1.50,5.50),[(2.00,6.00), (1.00,5.00)]}, 
{(1.00,3.00),[(1.00,3.00)]}, 
{(3.00,2.00),[(3.00,2.00)]}, 
{(4.00,3.00),[(4.00,3.00)]}, 
{(7.00,1.00),[(7.00,1.00)]}, 
{(7.00,5.50),[(7.00,6.00), (7.00,5.00)]}, 
{(3.00,4.00),[(3.00,4.00)]}, 
{(6.00,3.50),[(6.00,3.00), (6.00,4.00)]}, 
{(5.00,6.00),[(5.00,6.00)]}]

 9 clusters:
[
{(1.00,1.00),[(1.00,1.00)]}, 
{(1.50,5.50),[(2.00,6.00), (1.00,5.00)]}, 
{(1.00,3.00),[(1.00,3.00)]}, 
{(7.00,1.00),[(7.00,1.00)]}, 
{(7.00,5.50),[(7.00,6.00), (7.00,5.00)]}, 
{(3.50,2.50),[(3.00,2.00), (4.00,3.00)]}, 
{(3.00,4.00),[(3.00,4.00)]}, 
{(6.00,3.50),[(6.00,3.00), (6.00,4.00)]}, 
{(5.00,6.00),[(5.00,6.00)]}]

 8 clusters:
[
{(1.00,1.00),[(1.00,1.00)]}, 
{(1.50,5.50),[(2.00,6.00), (1.00,5.00)]}, 
{(1.00,3.00),[(1.00,3.00)]}, 
{(3.33,3.00),[(3.00,2.00), (4.00,3.00), (3.00,4.00)]}, 
{(7.00,1.00),[(7.00,1.00)]}, 
{(7.00,5.50),[(7.00,6.00), (7.00,5.00)]}, 
{(6.00,3.50),[(6.00,3.00), (6.00,4.00)]}, 
{(5.00,6.00),[(5.00,6.00)]}]

 7 clusters:
[
{(1.50,5.50),[(2.00,6.00), (1.00,5.00)]}, 
{(3.33,3.00),[(3.00,2.00), (4.00,3.00), (3.00,4.00)]}, 
{(1.00,2.00),[(1.00,1.00), (1.00,3.00)]}, 
{(7.00,1.00),[(7.00,1.00)]}, 
{(7.00,5.50),[(7.00,6.00), (7.00,5.00)]}, 
{(6.00,3.50),[(6.00,3.00), (6.00,4.00)]}, 
{(5.00,6.00),[(5.00,6.00)]}]

 6 clusters:
[
{(1.50,5.50),[(2.00,6.00), (1.00,5.00)]}, 
{(3.33,3.00),[(3.00,2.00), (4.00,3.00), (3.00,4.00)]}, 
{(1.00,2.00),[(1.00,1.00), (1.00,3.00)]}, 
{(6.33,5.67),[(7.00,6.00), (7.00,5.00), (5.00,6.00)]}, 
{(7.00,1.00),[(7.00,1.00)]}, 
{(6.00,3.50),[(6.00,3.00), (6.00,4.00)]}]

 5 clusters:
[
{(6.20,4.80),[(6.00,3.00), (7.00,6.00), (7.00,5.00), (6.00,4.00), (5.00,6.00)]}, 
{(1.50,5.50),[(2.00,6.00), (1.00,5.00)]}, 
{(3.33,3.00),[(3.00,2.00), (4.00,3.00), (3.00,4.00)]}, 
{(1.00,2.00),[(1.00,1.00), (1.00,3.00)]}, 
{(7.00,1.00),[(7.00,1.00)]}]

 4 clusters:
[
{(6.20,4.80),[(6.00,3.00), (7.00,6.00), (7.00,5.00), (6.00,4.00), (5.00,6.00)]}, 
{(1.50,5.50),[(2.00,6.00), (1.00,5.00)]}, 
{(7.00,1.00),[(7.00,1.00)]}, 
{(2.40,2.60),[(1.00,1.00), (3.00,2.00), (4.00,3.00), (3.00,4.00), (1.00,3.00)]}]

 3 clusters:
[
{(6.20,4.80),[(6.00,3.00), (7.00,6.00), (7.00,5.00), (6.00,4.00), (5.00,6.00)]}, 
{(7.00,1.00),[(7.00,1.00)]}, 
{(2.14,3.43),[(1.00,1.00), (2.00,6.00), (3.00,2.00), (4.00,3.00), (3.00,4.00), (1.00,3.00), (1.00,5.00)]}]

weka实现

import java.util.ArrayList;
import weka.clusterers.HierarchicalClusterer;
import static weka.clusterers.HierarchicalClusterer.TAGS_LINK_TYPE;
import weka.core.Attribute;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.SelectedTag;
import weka.core.SparseInstance;

public class WekaHierarchicalClustering {
    private static final double[][] DATA = {{1,1}, {1,3}, {1,5}, {2,6}, {3,2}, 
        {3,4}, {4,3}, {5,6}, {6,3}, {6,4}, {7,1}, {7,5}, {7,6}};
    private static final int M = DATA.length;  // number of points
    private static final int K = 3;            // number of clusters

    public static void main(String[] args) {
        Instances dataset = load(DATA);
        HierarchicalClusterer hc = new HierarchicalClusterer();
        hc.setLinkType(new SelectedTag(4, TAGS_LINK_TYPE));  // CENTROID
        hc.setNumClusters(3);
        try {
            hc.buildClusterer(dataset);
            for (Instance instance : dataset) {
                System.out.printf("(%.0f,%.0f): %s%n", 
                        instance.value(0), instance.value(1), 
                        hc.clusterInstance(instance));
            }
        } catch (Exception e) {
            System.err.println(e);
        }
    }
    
    private static Instances load(double[][] data) {
        ArrayList<Attribute> attributes = new ArrayList<Attribute>();
        attributes.add(new Attribute("X"));
        attributes.add(new Attribute("Y"));
        Instances dataset = new Instances("Dataset", attributes, M);
        for (double[] datum : data) {
            Instance instance = new SparseInstance(2);
            instance.setValue(0, datum[0]);
            instance.setValue(1, datum[1]);
            dataset.add(instance);
        }
        return dataset;
    }
}

结果-->

(1,1): 0
(1,3): 0
(1,5): 0
(2,6): 0
(3,2): 0
(3,4): 0
(4,3): 0
(5,6): 1
(6,3): 1
(6,4): 1
(7,1): 2
(7,5): 1
(7,6): 1

weka画图

import java.awt.BorderLayout;
import java.awt.Container;
import java.util.ArrayList;
import javax.swing.JFrame;
import weka.clusterers.HierarchicalClusterer;
import static weka.clusterers.HierarchicalClusterer.TAGS_LINK_TYPE;
import weka.core.Attribute;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.SelectedTag;
import weka.core.SparseInstance;
import weka.gui.hierarchyvisualizer.HierarchyVisualizer;

public class WekaHierarchicalClustering2 {
    private static final double[][] DATA = {{1,1}, {1,3}, {1,5}, {2,6}, {3,2}, 
        {3,4}, {4,3}, {5,6}, {6,3}, {6,4}, {7,1}, {7,5}, {7,6}};
    private static final int M = DATA.length;  // number of points
    private static final int K = 3;            // number of clusters

    public static void main(String[] args) {
        Instances dataset = load(DATA);
        HierarchicalClusterer hc = new HierarchicalClusterer();
        hc.setLinkType(new SelectedTag(4, TAGS_LINK_TYPE));  // CENTROID
        hc.setNumClusters(1);
        try {
            hc.buildClusterer(dataset);
            for (Instance instance : dataset) {
                System.out.printf("(%.0f,%.0f): %s%n", 
                        instance.value(0), instance.value(1), 
                        hc.clusterInstance(instance));
            }
            displayDendrogram(hc.graph());
        } catch (Exception e) {
            System.err.println(e);
        }
    }
    
    private static Instances load(double[][] data) {
        ArrayList<Attribute> attributes = new ArrayList<Attribute>();
        attributes.add(new Attribute("X"));
        attributes.add(new Attribute("Y"));
        Instances dataset = new Instances("Dataset", attributes, M);
        for (double[] datum : data) {
            Instance instance = new SparseInstance(2);
            instance.setValue(0, datum[0]);
            instance.setValue(1, datum[1]);
            dataset.add(instance);
        }
        return dataset;
    }
    
    public static void displayDendrogram(String graph) {
        JFrame frame = new JFrame("Dendrogram");
        frame.setSize(500, 400);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        Container pane = frame.getContentPane();
        pane.setLayout(new BorderLayout());
        pane.add(new HierarchyVisualizer(graph));
        frame.setVisible(true);
    }
}

 

K-均值聚类

• 需求：同上
• 实现：从数据集中选k个点创建k个聚类，其余点添加到最近的聚类中，重新计算中心

KMeans.java（普通实现）

import java.util.HashSet;
import java.util.Random;
import java.util.Set;

public class KMeans {
    private static final double[][] DATA = {{1,1}, {1,3}, {1,5}, {2,6}, {3,2},
            {3,4}, {4,3}, {5,6}, {6,3}, {6,4}, {7,1}, {7,5}, {7,6}};
    private static final int M = DATA.length;
    private static final int K = 3;
    private static HashSet<Point> points;
    private static HashSet<Cluster> clusters = new HashSet();
    private static Random RANDOM = new Random();

    public static void main(String[] args){
        points = load(DATA);

        int i0 = RANDOM.nextInt(M);
        Point p = new Point(DATA[i0][0],DATA[i0][1]);
        points.remove(p);

        HashSet<Point> initSet = new HashSet();
        initSet.add(p);

        for(int i = 1; i < K; i ++){
            p = farthestFrom(initSet);
            initSet.add(p);
            points.remove(p);
        }

        for(Point point:initSet){
            Cluster cluster = new Cluster(point);
            clusters.add(cluster);
        }

        for(Point point:points){
            Cluster cluster = closestTo(point);
            cluster.add(point);
            cluster.recomputeCentroid();
        }
        System.out.println(clusters);
    }

    private static HashSet<Point> load(double[][] data) {
        HashSet<Point> points = new HashSet();
        for (double[] datum : DATA) {
            points.add(new Point(datum[0], datum[1]));
        }
        return points;
    }

    // return the cluster whose centroid is closet to the specified point
    private static Cluster closestTo(Point point){
        double minDist = Double.POSITIVE_INFINITY;
        Cluster c = null;
        for(Cluster cluster:clusters){
            double d = distance2(cluster.getCentroid(),point);
            if(d < minDist){
                minDist = d;
                c = cluster;
            }
        }
        return c;
    }

    // return the point that is farthest from the specified set
    private static Point farthestFrom(Set<Point> set){
        Point p = null;
        double maxDist = 0.0;
        for(Point point:points){
            if(set.contains(point)){
                continue;
            }
            double d = dist(point,set);
            if(d > maxDist){
                p = point;
                maxDist = d;
            }
        }
        return p;
    }

    // return the distance from p to the nearest point in the set
    public static double dist(Point p, Set<Point> set){
        double minDist = Double.POSITIVE_INFINITY;
        for(Point point:set){
            double d = distance2(p,point);
            minDist = (d < minDist ? d : minDist);
        }
        return minDist;
    }

    public static double distance2(Point p, Point q){
        double dx = p.getX() - q.getX();
        double dy = p.getY() - q.getY();
        return dx*dx + dy*dy;
    }
}

[{(2.40,2.60),[(1.00,1.00), (1.00,3.00), (3.00,2.00), (4.00,3.00), (3.00,4.00)]},
{(6.33,4.17),[(6.00,3.00), (7.00,6.00), (6.00,4.00), (7.00,5.00), (7.00,1.00), (5.00,6.00)]},
{(1.50,5.50),[(2.00,6.00), (1.00,5.00)]}]

KMeans.java（Weka 实现）

import java.util.ArrayList;
import weka.clusterers.SimpleKMeans;
import weka.core.Attribute;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.SparseInstance;

public class KMeans {
    private static final double[][] DATA = {{1,1}, {1,3}, {1,5}, {2,6}, {3,2}, 
        {3,4}, {4,3}, {5,6}, {6,3}, {6,4}, {7,1}, {7,5}, {7,6}};
    private static final int M = DATA.length;  // number of points
    private static final int K = 3;            // number of clusters

    public static void main(String[] args) {
        Instances dataset = load(DATA);
        SimpleKMeans skm = new SimpleKMeans();
        System.out.printf("%d clusters:%n", K);
        try {
            skm.setNumClusters(K);
            skm.buildClusterer(dataset);
            for (Instance instance : dataset) {
                System.out.printf("(%.0f,%.0f): %s%n", 
                        instance.value(0), instance.value(1), 
                        skm.clusterInstance(instance));
            }
        } catch (Exception e) {
            System.err.println(e);
        }
    }
    
    private static Instances load(double[][] data) {
        ArrayList<Attribute> attributes = new ArrayList<Attribute>();
        attributes.add(new Attribute("X"));
        attributes.add(new Attribute("Y"));
        Instances dataset = new Instances("Dataset", attributes, M);
        for (double[] datum : data) {
            Instance instance = new SparseInstance(2);
            instance.setValue(0, datum[0]);
            instance.setValue(1, datum[1]);
            dataset.add(instance);
        }
        return dataset;
    }
}

结果-->

(1,1): 1
(1,3): 1
(1,5): 0
(2,6): 0
(3,2): 1
(3,4): 0
(4,3): 0
(5,6): 0
(6,3): 2
(6,4): 2
(7,1): 2
(7,5): 2
(7,6): 2

KMeansPlusPlus.java（Apache Common Math 实现）

import java.util.ArrayList;
import java.util.List;
import org.apache.commons.math3.ml.clustering.CentroidCluster;
import org.apache.commons.math3.ml.clustering.DoublePoint;
import org.apache.commons.math3.ml.clustering.KMeansPlusPlusClusterer;
import org.apache.commons.math3.ml.distance.EuclideanDistance;

public class KMeansPlusPlus {
    private static final double[][] DATA = {{1,1}, {1,3}, {1,5}, {2,6}, {3,2}, 
        {3,4}, {4,3}, {5,6}, {6,3}, {6,4}, {7,1}, {7,5}, {7,6}};
    private static final int M = DATA.length;  // number of points
    private static final int K = 3;  // number of clusters
    private static final int MAX = 100;  // maximum number of iterations
    private static final EuclideanDistance ED = new EuclideanDistance();
    
    public static void main(String[] args) {
        List<DoublePoint> points = load(DATA);
        KMeansPlusPlusClusterer<DoublePoint> clusterer;
        clusterer = new KMeansPlusPlusClusterer(K, MAX, ED);
        List<CentroidCluster<DoublePoint>> clusters = clusterer.cluster(points);
        
        for (CentroidCluster<DoublePoint> cluster : clusters) {
            System.out.println(cluster.getPoints());
        }
    }
    
    private static List<DoublePoint> load(double[][] data) {
        List<DoublePoint> points = new ArrayList(M);
        for (double[] pair : data) {
            points.add(new DoublePoint(pair));            
        }
        return points;
    } 
}

[[5.0, 6.0], [6.0, 3.0], [6.0, 4.0], [7.0, 5.0], [7.0, 6.0]]
[[1.0, 1.0], [1.0, 3.0], [1.0, 5.0], [2.0, 6.0], [3.0, 2.0], [3.0, 4.0], [4.0, 3.0]]
[[7.0, 1.0]]

仿射传播聚类

• 需求：同上
• 实现：
• 特点：不同于KMeans，聚类个数k不需事先确定，

public class AffinityPropagation {
    private static double[][] x = {{1,2}, {2,3}, {4,1}, {4,4}, {5,3}};
    private static int n = x.length;                 // number of points
    private static double[][] s = new double[n][n];  // similarities
    private static double[][] r = new double[n][n];  // responsibilities
    private static double[][] a = new double[n][n];  // availabilities
    private static final int ITERATIONS = 10;
    private static final double DAMPER = 0.5;

    public static void main(String[] args) {
        initSimilarities();
        for (int i = 0; i < ITERATIONS; i++) {
            updateResponsibilities();
            updateAvailabilities();
        }
        printResults();
    }
    
    private static void initSimilarities() {
        double sum = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < i; j++) {
                sum += s[i][j] = s[j][i] = negSqEuclidDist(x[i], x[j]);
            }
        }
        double average = 2*sum/(n*n - n);  // average of s[i][j] for j < i
        for (int i = 0; i < n; i++) {
            s[i][i] = average;
        }
    }
    
    private static void updateResponsibilities() {
        for (int i = 0; i < n; i++) {
            for (int k = 0; k < n; k++) {
                double oldValue = r[i][k];
                double max = Double.NEGATIVE_INFINITY;
                for (int j = 0; j < n; j++) {
                    if (j != k) {
                        max = Math.max(max, a[i][j] + s[i][j]);
                    }
                }
                double newValue = s[i][k] - max;
                r[i][k] = DAMPER*oldValue + (1 - DAMPER)*newValue;
            }
        }
    }
    
    private static void updateAvailabilities() {
        for (int i = 0; i < n; i++) {
            for (int k = 0; k < n; k++) {
                double oldValue = a[i][k];
                double newValue = Math.min(0, r[k][k] + sumOfPos(i,k));
                if (k == i) {
                    newValue = sumOfPos(k,k);
                }
                a[i][k] = DAMPER*oldValue + (1 - DAMPER)*newValue;
            }
        }
    }
    
    /*  Returns the negative square of the Euclidean distance from x to y.
    */
    private static double negSqEuclidDist(double[] x, double[] y) {
        double d0 = x[0] - y[0];
        double d1 = x[1] - y[1];
        return -(d0*d0 + d1*d1);
    }
    
    /*  Returns the sum of the positive r[j][k] excluding r[i][k] and r[k][k].
    */
    private static double sumOfPos(int i, int k) {
        double sum = 0;
        for (int j = 0; j < n; j++) {
            if (j != i && j != k) {
                sum += Math.max(0, r[j][k]);
            }
        }
        return sum;
    }
    
    private static void printResults() {
        for (int i = 0; i < n; i++) {
            double max = a[i][0] + r[i][0];
            int k = 0;
            for (int j = 1; j < n; j++) {
                double arij = a[i][j] + r[i][j];
                if (arij > max) {
                    max = arij;
                    k = j;
                }
            }
            System.out.printf("point %d has exemplar point %d%n", i, k);
        }
    }
}

point 0 has exemplar point 1
point 1 has exemplar point 1
point 2 has exemplar point 4
point 3 has exemplar point 4
point 4 has exemplar point 4

参考

https://blog.csdn.net/xzfreewind/article/details/73770327