MinimumCostPolygonTriangulation (williamfiset#164)

* MinimumCostPolygonTriangulation

* style fix

* updating tests, renaming files, comments

Author: bbowles98

src/main/java/com/williamfiset/algorithms/geometry/MinimumCostConvexPolygonTriangulation.java

@@ -0,0 +1,39 @@
+/**
+ * This file shows you how to find the minimum cost convex polygon triangulation of a set of points.
+ * Points must be in either clockwise or counterclockwise order.
+ *
+ * <p>Time Complexity: O(n^3)
+ *
+ * @author Bryan Bowles
+ */
+package com.williamfiset.algorithms.geometry;
+
+import java.awt.geom.Point2D;
+
+// Problem explanation: https://www.geeksforgeeks.org/minimum-cost-polygon-triangulation/
+public class MinimumCostConvexPolygonTriangulation {
+
+  // Returns the perimeter (cost) of the triangle
+  private static double cost(Point2D i, Point2D j, Point2D k) {
+    return i.distance(j) + i.distance(k) + j.distance(k);
+  }
+
+  public static double minimumCostTriangulation(Point2D[] points) {
+    int len = points.length;
+    if (len < 3) return 0;
+
+    double[][] dp = new double[len][len];
+    for (int i = 2; i < len; i++) {
+      for (int j = 0; j + i < len; j++) {
+        dp[j][j + i] = Integer.MAX_VALUE;
+        for (int k = j + 1; k < j + i; k++) {
+          dp[j][j + i] =
+              Math.min(
+                  dp[j][j + i],
+                  dp[j][k] + dp[k][j + i] + cost(points[j], points[j + i], points[k]));
+        }
+      }
+    }
+    return dp[0][len - 1];
+  }
+}

src/test/java/com/williamfiset/algorithms/geometry/MinimumCostConvexPolygonTriangulationTest.java

@@ -0,0 +1,51 @@
+package com.williamfiset.algorithms.geometry;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import java.awt.geom.*;
+import org.junit.*;
+
+public class MinimumCostConvexPolygonTriangulationTest {
+
+  private static final double TOLERANCE = 1e-3;
+
+  @Test
+  public void MinimumCostConvexPolygonTriangulationBasicTest() {
+    Point2D[] pts = new Point2D[5];
+
+    pts[0] = new Point2D.Double(0, 0);
+    pts[1] = new Point2D.Double(1, 0);
+    pts[2] = new Point2D.Double(2, 1);
+    pts[3] = new Point2D.Double(1, 2);
+    pts[4] = new Point2D.Double(0, 2);
+
+    double cost = MinimumCostConvexPolygonTriangulation.minimumCostTriangulation(pts);
+    assertThat(cost).isWithin(TOLERANCE).of(15.3);
+  }
+
+  @Test
+  public void MinimumCostConvexPolygonTriangulationInvalidTest() {
+    Point2D[] pts = new Point2D[2];
+
+    pts[0] = new Point2D.Double(0, 0);
+    pts[1] = new Point2D.Double(1, 0);
+
+    double cost = MinimumCostConvexPolygonTriangulation.minimumCostTriangulation(pts);
+    assertThat(cost).isEqualTo(0);
+  }
+
+  @Test
+  public void MinimumCostConvexPolygonTriangulationConvex() {
+    Point2D[] pts = new Point2D[6];
+
+    pts[0] = new Point2D.Double(0, 0);
+    pts[1] = new Point2D.Double(4, 0);
+    pts[2] = new Point2D.Double(4, 2);
+    pts[3] = new Point2D.Double(1, 3);
+    pts[4] = new Point2D.Double(0, 2);
+    pts[5] = new Point2D.Double(0, 1);
+
+    double cost = MinimumCostConvexPolygonTriangulation.minimumCostTriangulation(pts);
+    assertThat(cost).isWithin(TOLERANCE).of(31.386);
+  }
+}