凸边形最优三角剖分（dp）

dp[i][j]表示Ai->Aj的最优权值。
Ai表示vi-1 vi 边
v表示顶点。
经过分析，该问题与矩阵连乘非常相似。
矩阵连乘参考链接

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

const int N=5;
int dp[N+1][N+1];
int s[N+1][N+1];
int weight[][N+1] = {{0,2,2,3,1,4},             //懒得计算每一个边长，直接从网上搜了一组数据。
                     {2,0,1,5,2,3},
                     {2,1,0,2,1,4},
                     {3,5,2,0,6,2},
                     {1,2,1,6,0,1},
                     {4,3,4,2,1,0}};

void back_track(int a, int b)
{
    if (a == b) return;
    back_track(a,s[a][b]);
    back_track(s[a][b]+1,b);    //记得这是要加一
    printf("最优三角: V%d V%d V%d.\n",a-1,s[a][b],b);       //a记得要减1。
}

int w(int a,int b,int c)
{
    return weight[a][b]+weight[b][c]+weight[a][c];
}

void minWeightTriangulation()
{
    for(int i=1;i<=N;i++)
        dp[i][i]=0;
    for(int r=2;r<=N;r++)
        for(int i=1;i<=N-r+1;i++)
        {
            int j=i+r-1;
            dp[i][j]=dp[i][i]+dp[i+1][j]+w(i-1,i,j);
            s[i][j]=i;
            for(int k=i+1;k<j;k++)
            {
                int t=dp[i][k]+dp[k+1][j]+w(i-1,k,j);
                if(t<dp[i][j])
                {
                    dp[i][j]=t;
                    s[i][j]=k;
                }
            }
        }
}

int main()
{
    minWeightTriangulation();
    printf("最优解：%d\n",dp[1][N]);
    back_track(1,N);
    return 0;
}