add A-star search algorithm

Author: Flians

Graph Computing.xmind

@@ -0,0 +1,31 @@
+package com.antfin.util;
+
+
+import java.util.List;
+
+public class EuclideanDistance implements DistanceFunction {
+
+    public EuclideanDistance() {
+
+    }
+
+    public double calcDistance(List<Double> vector1, List<Double> vector2) {
+       if (vector1.size() != vector2.size()) {
+          throw new InternalError("ERROR:  cannot calculate the distance "
+              + "between vectors of different sizes.");
+       }
+
+        double sqSum = 0.0;
+       for (int x = 0; x < vector1.size(); x++) {
+          sqSum += Math.pow(vector1.get(x) - vector2.get(x), 2.0);
+       }
+
+        return Math.sqrt(sqSum);
+    }  // end class euclideanDist(..)
+
+    @Override
+    public double calcDistance(Object a, Object b) {
+        return this.calcDistance((List<Double>) a, (List<Double>) b);
+    }
+
+}

reference/Shortest Path algorithm/A Formal Basis for the Heuristic Determination of Minimum Cost Paths.pdf

@@ -2,17 +2,23 @@
 
 import com.alipay.kepler.util.SerDeHelper;
 import com.antfin.arc.arch.message.graph.Edge;
+import com.antfin.arc.arch.message.graph.Vertex;
 import com.antfin.arch.cstore.benchmark.RandomWord;
+import com.antfin.graph.Graph;
+import com.antfin.graph.refObj.Graph_Map_CSR;
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.nio.charset.Charset;
 import java.nio.file.Files;
 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.PriorityQueue;
+import java.util.Queue;
 import javafx.util.Pair;
 
 public class GraphHelper {
@@ -111,7 +117,7 @@ public static Object loadObject(File file) throws IOException {
     }
 
     public static void writeObject(Object object, File file) throws IOException {
-        if(!file.getParentFile().exists()){
+        if (!file.getParentFile().exists()) {
             file.getParentFile().mkdirs();
         }
         file.createNewFile();
@@ -122,15 +128,15 @@ public static void writeObject(Object object, File file) throws IOException {
         opStream.close();
     }
 
-    public static List<Edge<String, String>> loadEdges(String path){
+    public static List<Edge<String, String>> loadEdges(String path) {
         List<Edge<String, String>> edges = new ArrayList<>();
-        readKVFile(path).forEach(pair->{
+        readKVFile(path).forEach(pair -> {
             edges.add(new Edge<>(pair.getKey(), pair.getValue(), RandomWord.getWords(100)));
         });
         return edges;
     }
 
-    public static List<Pair<String, String>> readKVFile(String path){
+    public static List<Pair<String, String>> readKVFile(String path) {
         File file = new File(path);
         if (!file.exists()) {
             System.err.println(path + " is not exist!");
@@ -140,11 +146,11 @@ public static List<Pair<String, String>> readKVFile(String path){
             String line = null;
             while ((line = reader.readLine()) != null) {
                 line = line.trim();
-                if (line.length() == 0)
+                if (line.length() == 0) {
                     continue;
+                }
                 String[] vid = line.split(" ");
-                if (vid.length != 2)
-                {
+                if (vid.length != 2) {
                     System.err.println(line + " must include source and sink!");
                 }
                 pairs.add(new Pair<>(vid[0], vid[1]));
@@ -154,4 +160,83 @@ public static List<Pair<String, String>> readKVFile(String path){
         }
         return pairs;
     }
+
+    /**
+     * return the closest distance from source to target by A* search algorithm.
+     */
+    public static <K> double getClosestDistance(Vertex source, Vertex target, Graph graph, Map<K, List<Double>> embedding, DistanceFunction disFun) {
+        return getClosestDistance((K) source.getId(), (K) target.getId(), graph, embedding, disFun);
+    }
+
+    public static <K> double getClosestDistance(K source, K target, Graph graph, Map<K, List<Double>> embedding, DistanceFunction disFun) {
+        if (source.equals(target)){
+            return 0.0;
+        }
+        double distanceBetweenNodes = 0;
+        Map<K, Integer> dictV;
+        // build Adjacency Matrix
+        if (graph instanceof Graph_Map_CSR) {
+            dictV = ((Graph_Map_CSR) graph).getDictV();
+        } else {
+            dictV = new HashMap<>();
+            System.err.format("The type of graph is not Graph_Map_CSR!");
+        }
+        // [H,G,F]
+        double[][] distance = new double[dictV.size()][2];
+        Queue<K> candidate = new PriorityQueue<K>(new Comparator<K>() {
+            public int compare(K c1, K c2) {
+                if (distance[dictV.get(c1)][2] > distance[dictV.get(c2)][2]) {
+                    return 1;
+                } else if (distance[dictV.get(c1)][2] == distance[dictV.get(c2)][2]) {
+                    return 0;
+                } else {
+                    return -1;
+                }
+            }
+        });
+        boolean[] closed = new boolean[dictV.size()];
+        // record the path <node, parent>
+        Map<K, K> shortestPath = new HashMap<>();
+        // init
+        distance[dictV.get(target)][1] = Double.MIN_VALUE;
+        distance[dictV.get(source)][0] = disFun.calcDistance(embedding.get(source), embedding.get(target));
+        distance[dictV.get(source)][1] = 0.0;
+        distance[dictV.get(source)][2] = distance[dictV.get(source)][0] + distance[dictV.get(source)][1];
+        candidate.add(source);
+        while (!candidate.isEmpty()) {
+            K cur = candidate.poll();
+            closed[dictV.get(cur)] = true;
+            for (Object e : ((List) graph.getEdge(cur))){
+                K nbr = (K) ((Edge)e).getTargetId();
+                if (!closed[dictV.get(nbr)]) {
+                    double h = disFun.calcDistance(embedding.get(nbr), embedding.get(target));
+                    double g = distance[dictV.get(cur)][1] + distanceBetweenNodes;
+                    double f = h + g;
+
+                    if (!candidate.contains(nbr)) {
+                        shortestPath.put(nbr, cur);
+                        candidate.add(nbr);
+                        distance[dictV.get(nbr)][0] = h;
+                        distance[dictV.get(nbr)][1] = g;
+                        distance[dictV.get(nbr)][2] = f;
+                    } else if (f < distance[dictV.get(nbr)][2]) {
+                        shortestPath.put(nbr, cur);
+                        distance[dictV.get(nbr)][1] = g;
+                        distance[dictV.get(nbr)][2] = f;
+                    }
+                }
+            }
+            if (cur.equals(target)) {
+                StringBuilder sb = new StringBuilder();
+                while (!shortestPath.get(target).equals(source)) {
+                    sb.append(target).append(" <- ");
+                    target = shortestPath.get(target);
+                }
+                sb.append(source);
+                System.out.println("The path is: " + sb.reverse().toString());
+                return distance[dictV.get(target)][1];
+            }
+        }
+        return distance[dictV.get(target)][1];
+    }
 }

reference/Shortest Path algorithm/A-starSearch.pdf

@@ -0,0 +1,31 @@
+package com.antfin.util;
+
+
+import java.util.List;
+
+public class ManhattanDistance implements DistanceFunction {
+
+    public ManhattanDistance() {
+
+    }
+
+    public double calcDistance(List<Double> vector1, List<Double> vector2) {
+        if (vector1.size() != vector2.size()) {
+            throw new InternalError("ERROR:  cannot calculate the distance "
+                + "between vectors of different sizes.");
+        }
+
+        double diffSum = 0.0;
+        for (int x = 0; x < vector1.size(); x++) {
+            diffSum += Math.abs(vector1.get(x) - vector2.get(x));
+        }
+
+        return diffSum;
+    }
+
+    @Override
+    public double calcDistance(Object a, Object b) {
+        return this.calcDistance((List<Double>)a, (List<Double>) b);
+    }
+
+}