Minimum Cost Polygon Triangulation

using System;
using System.Collections.Generic;

// Class to store a point in the Euclidean plane
public  class Point {
  public int x, y;

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

  // Utility function to return the distance between two
  // vertices in a 2-dimensional plane
  public double dist(Point p) {

    // The distance between vertices `(x1, y1)` & `(x2,
    // y2)` is `?((x2 ? x1) ^ 2 + (y2 ? y1) ^ 2)`
    return Math.Sqrt((this.x - p.x) * (this.x - p.x) + 
                     (this.y - p.y) * (this.y - p.y));
  }
}

public class GFG {

  // Function to calculate the weight of optimal
  // triangulation of a convex polygon represented by a
  // given set of vertices `vertices[i..j]`
  public static double MWT(Point[] vertices, int i, int j) {

    // If the polygon has less than 3 vertices,
    // triangulation is not possible
    if (j < i + 2) {
      return 0;
    }

    // keep track of the total weight of the minimum
    // weight triangulation of `MWT(i,j)`
    double cost = 9999999999999.09;

    // consider all possible triangles `ikj` within the
    // polygon
    for (int k = i + 1; k <= j - 1; k++) {

      // The weight of a triangulation is the length
      // of perimeter of the triangle
      double weight = vertices[i].dist(vertices[j]) + 
        vertices[j].dist(vertices[k])
        + vertices[k].dist(vertices[i]);

      // choose the vertex `k` that leads to the
      // minimum total weight
      cost = Math.Min(cost, weight + 
                      MWT(vertices, i, k) + 
                      MWT(vertices, k, j));
    }
    return Math.Round(cost,4);
  }

  // Driver code
  public static void Main(String[] args) {

    // vertices are given in clockwise order
    Point[] vertices = { new Point(0, 0),
                        new Point(2, 0), 
                        new Point(2, 1), 
                        new Point(1, 2), 
                        new Point(0, 1) };

    Console.WriteLine(MWT(vertices, 0, vertices.Length - 1));
  }
}

// This code is contributed by gauravrajput1 

using System;

// A Dynamic Programming based program to find minimum cost
// of convex polygon triangulation

// Structure of a point in 2D plane
public class Point {
  public int x;
  public int y;
}

public static class Globals {
  public const double MAX = 1000000.0;
  // Utility function to find minimum of two double values
  public static double min(double x, double y)
  {
    return (x <= y) ? x : y;
  }

  // A utility function to find distance between two
  // points in a plane
  public static double dist(Point p1, Point p2)
  {
    return Math.Sqrt((p1.x - p2.x) * (p1.x - p2.x)
                     + (p1.y - p2.y) * (p1.y - p2.y));
  }

  // A utility function to find cost of a triangle. The
  // cost is considered as perimeter (sum of lengths of
  // all edges) of the triangle
  public static double cost(Point[] points, int i, int j,
                            int k)
  {
    Point p1 = points[i];
    Point p2 = points[j];
    Point p3 = points[k];

    return (dist(p1, p2) + dist(p2, p3) + dist(p3, p1));
  }

  // A Dynamic programming based function to find minimum
  // cost for convex polygon triangulation.
  public static double mTCDP(Point[] points, int n)
  {
    // There must be at least 3 points to form a
    // triangle
    if (n < 3) {
      return 0;
    }

    // table to store results of subproblems.
    // table[i][j] stores cost of triangulation of
    // points from i to j. The entry table[0][n-1]
    // stores the final result.
    double[, ] table = new double[n, n];
    ;

    // Fill table using above recursive formula. Note
    // that the table is filled in diagonal fashion
    // i.e., from diagonal elements to table[0][n-1]
    // which is the result.
    for (int gap = 0; gap < n; gap++) {
      for (int i = 0, j = gap; j < n; i++, j++) {
        if (j < i + 2) {
          table[i, j] = 0.0;
        }
        else {
          table[i, j] = MAX;
          for (int k = i + 1; k < j; k++) {
            double val
              = table[i, k] + table[k, j]
              + cost(points, i, j, k);
            if (table[i, j] > val) {
              table[i, j] = val;
            }
          }
        }
      }
    }
    return table[0, n - 1];
  }

  // Driver program to test above functions
  public static void Main()
  {
    Point[] points = { new Point(){ x = 0, y = 0 },
                      new Point(){ x = 1, y = 0 },
                      new Point(){ x = 2, y = 1 },
                      new Point(){ x = 1, y = 2 },
                      new Point(){ x = 0, y = 2 } };

    int n = points.Length;
    Console.Write(mTCDP(points, n));
  }
}

// This code is contributed by Aarti_Rathi