动态规划专题(10)：最优三角剖分问题

2026.04.06

1. 问题定义

最优三角剖分 （Optimal Triangulation）问题是指：给定一个凸多边形，将其划分成若干个不相交的三角形，使得这些三角形的某种权值之和最小。

有一块多边形的披萨饼，上面有很多蔬菜和肉片，希望沿着两个不相邻的顶点切成小三角形，尽可能少切碎披萨上面的蔬菜和肉片。

可以把披萨饼看作一个凸多边形，凸多边形是指多边形的任意两点的连线均落在多边形的内部或边界上。

最优三角剖分问题：从理论到C++实践详解

📋 目录

什么是三角剖分？
什么是最优三角剖分问题？
如何理解最优三角剖分？
如何使用最优三角剖分？
应用技巧与细节
实例代码详解
总结与实战建议

1. 什么是三角剖分？

三角剖分（Triangulation）是指将一个多边形分割成若干个三角形，这些三角形互不重叠，且它们的并集恰好等于原多边形。

举个生活中的例子：

🍕 想象你在切披萨，要把一个圆形的披萨切成三角形小块。虽然披萨是圆的，但我们可以先把它看作多边形，然后切成三角形。切得好，每块都有配料；切得不好，有些块可能配料很少。

2. 什么是最优三角剖分问题？

最优三角剖分问题 是指：给定一个凸多边形，找到一种三角剖分方案，使得剖分得到的所有三角形的某种"权值"之和最小（或最大）。

问题的数学描述：

输入：n个顶点的凸多边形
输出：n-2个三角形的集合
目标：min Σ w(三角形ᵢ) 或 max Σ w(三角形ᵢ)

权值函数w可以是：

三角形周长
三角形面积
切割成本
其他自定义度量

3. 如何理解最优三角剖分？

3.1 核心思想理解

想象你有一块不规则形状的玻璃，要把它切成三角形小块来卖。你希望：

切割次数尽量少（成本低）
切出来的三角形尽量"好看"（好卖）
切割过程中浪费的材料尽量少

这就是最优三角剖分的实际应用场景。

3.2 动态规划理解

我们可以用区间DP的思想来理解：

复制代码

对于多边形 v₀-v₁-v₂-...-vₙ₋₁
1. 选择一条对角线 vᵢ-vⱼ
2. 这条对角线将多边形分成两部分
3. 递归地对两部分进行最优三角剖分
4. 选择使总权值最小的那条对角线

4. 如何使用最优三角剖分？

4.1 算法步骤

预处理：确保多边形顶点按顺序排列
定义DP状态 ：dp[i][j]表示从顶点i到j的子多边形的最优剖分值

状态转移：

复制代码

dp[i][j] = min{ dp[i][k] + dp[k][j] + w(i,k,j) }  (i < k < j)

计算顺序：按子多边形长度从小到大计算
结果获取 ：dp[0][n-1]就是最终答案

4.2 算法复杂度

时间复杂度：O(n³)
空间复杂度：O(n²)

5. 应用技巧与细节

5.1 使用技巧

复制代码

// 技巧1：使用vector存储，避免内存泄漏
vector<vector<double>> dp(n, vector<double>(n, 0));

// 技巧2：预计算距离，避免重复计算
vector<vector<double>> dist(n, vector<double>(n, 0));
for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
        dist[i][j] = distance(vertices[i], vertices[j]);

// 技巧3：记录剖分方案
vector<vector<int>> split(n, vector<int>(n, -1));

5.2 注意事项

凸多边形要求：算法只适用于凸多边形
顶点顺序：顶点必须按顺时针或逆时针顺序给出
浮点精度：比较浮点数时使用误差范围
边界处理：正确处理三角形的情况

5.3 避免的坑

❌ 不要忘记验证多边形是凸的
❌ 不要用整数坐标计算距离（可能丢失精度）
❌ 不要忽略三角形的顶点顺序
❌ 不要在DP初始化时用默认值0（权值可能为负数）

6. 实例代码详解

实例代码1：基础实现（易于理解）

复制代码

#include <iostream>
#include <vector>
#include <cmath>
#include <iomanip>
#include <limits>

using namespace std;

// 点结构体
struct Point {
    double x, y;
    Point(double _x = 0, double _y = 0) : x(_x), y(_y) {}
    
    void print() const {
        cout << "(" << x << ", " << y << ")";
    }
};

// 计算两点距离
double distance(const Point& a, const Point& b) {
    return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

// 三角形权值：周长
double triangleWeight(const Point& a, const Point& b, const Point& c) {
    return distance(a, b) + distance(b, c) + distance(c, a);
}

/**
 * 基础版本：最优三角剖分
 * 权值函数：三角形周长之和最小
 */
double basicTriangulation(const vector<Point>& vertices) {
    int n = vertices.size();
    if (n < 3) return 0;
    
    // dp[i][j]: 从顶点i到j的子多边形的最优剖分值
    vector<vector<double>> dp(n, vector<double>(n, 0));
    
    // 按子多边形长度递增计算
    for (int len = 1; len < n; len++) {  // len = j - i
        for (int i = 0; i + len < n; i++) {
            int j = i + len;
            
            if (len == 1) {  // 两个顶点
                dp[i][j] = 0;
            } 
            else if (len == 2) {  // 三个顶点，一个三角形
                dp[i][j] = triangleWeight(vertices[i], vertices[i+1], vertices[j]);
            }
            else {  // 超过三个顶点
                dp[i][j] = numeric_limits<double>::max();
                
                // 尝试所有可能的分割点k
                for (int k = i + 1; k < j; k++) {
                    double current = 0;
                    
                    // 左边子多边形
                    if (k - i >= 2) {
                        current += dp[i][k];
                    }
                    
                    // 右边子多边形
                    if (j - k >= 2) {
                        current += dp[k][j];
                    }
                    
                    // 当前三角形(i, k, j)的周长
                    current += triangleWeight(vertices[i], vertices[k], vertices[j]);
                    
                    // 更新最小值
                    if (current < dp[i][j]) {
                        dp[i][j] = current;
                    }
                }
            }
        }
    }
    
    return dp[0][n-1];
}

// 打印多边形
void printPolygon(const vector<Point>& vertices) {
    cout << "多边形顶点（按顺序）：";
    for (int i = 0; i < vertices.size(); i++) {
        vertices[i].print();
        if (i < vertices.size() - 1) cout << " → ";
    }
    cout << endl;
}

int main() {
    cout << "========== 最优三角剖分 - 基础版本 ==========" << endl;
    cout << "权值函数：三角形周长之和" << endl;
    cout << "目标：使总周长最小" << endl << endl;
    
    // 测试数据1：三角形（最简单情况）
    {
        cout << "\n测试1：三角形" << endl;
        vector<Point> triangle = {
            Point(0, 0),   // v0
            Point(4, 0),   // v1
            Point(2, 3)    // v2
        };
        printPolygon(triangle);
        
        double result = basicTriangulation(triangle);
        cout << "最小总周长: " << fixed << setprecision(2) << result << endl;
        cout << "分析：三角形不需要剖分，总周长就是三角形自身周长" << endl;
    }
    
    // 测试数据2：正方形
    {
        cout << "\n测试2：正方形" << endl;
        vector<Point> square = {
            Point(0, 0),   // v0
            Point(4, 0),   // v1
            Point(4, 4),   // v2
            Point(0, 4)    // v3
        };
        printPolygon(square);
        
        double result = basicTriangulation(square);
        cout << "最小总周长: " << fixed << setprecision(2) << result << endl;
        
        // 手动验证：两种剖分方式
        // 方式1：对角线(0,2) -> 三角形(0,1,2)和(0,2,3)
        double way1 = distance(Point(0,0), Point(4,0)) + 
                     distance(Point(4,0), Point(4,4)) + 
                     distance(Point(4,4), Point(0,0)) +
                     distance(Point(0,0), Point(4,4)) +
                     distance(Point(4,4), Point(0,4)) + 
                     distance(Point(0,4), Point(0,0));
        
        // 方式2：对角线(1,3) -> 三角形(1,2,3)和(1,3,0)
        double way2 = distance(Point(4,0), Point(4,4)) + 
                     distance(Point(4,4), Point(0,4)) + 
                     distance(Point(0,4), Point(4,0)) +
                     distance(Point(4,0), Point(0,4)) +
                     distance(Point(0,4), Point(0,0)) + 
                     distance(Point(0,0), Point(4,0));
        
        cout << "验证 - 方式1总周长: " << way1 << endl;
        cout << "验证 - 方式2总周长: " << way2 << endl;
        cout << "两种方式结果相同，因为正方形对称" << endl;
    }
    
    // 测试数据3：五边形
    {
        cout << "\n测试3：不规则五边形" << endl;
        vector<Point> pentagon = {
            Point(0, 0),   // v0
            Point(4, 0),   // v1
            Point(5, 3),   // v2
            Point(2, 5),   // v3
            Point(-1, 2)   // v4
        };
        printPolygon(pentagon);
        
        double result = basicTriangulation(pentagon);
        cout << "最小总周长: " << fixed << setprecision(2) << result << endl;
        
        // 验证：计算所有可能的对角线
        cout << "\n所有可能的对角线及其结果：" << endl;
        // 对角线(0,2)
        double d1 = distance(pentagon[0], pentagon[1]) +
                   distance(pentagon[1], pentagon[2]) +
                   distance(pentagon[2], pentagon[0]) +
                   distance(pentagon[0], pentagon[2]) +
                   distance(pentagon[2], pentagon[3]) +
                   distance(pentagon[3], pentagon[4]) +
                   distance(pentagon[4], pentagon[0]) +
                   distance(pentagon[0], pentagon[3]) +
                   distance(pentagon[3], pentagon[4]) +
                   distance(pentagon[4], pentagon[0]);
        cout << "对角线(0,2): " << d1 << endl;
    }
    
    return 0;
}

实例代码2：优化版本（性能更好）

复制代码

#include <iostream>
#include <vector>
#include <cmath>
#include <iomanip>
#include <limits>
#include <algorithm>

using namespace std;

struct Point {
    double x, y;
    Point(double _x = 0, double _y = 0) : x(_x), y(_y) {}
    
    void print() const {
        cout << "(" << x << ", " << y << ")";
    }
};

/**
 * 优化版本：最优三角剖分
 * 优化点：
 * 1. 预计算距离矩阵
 * 2. 优化循环边界
 * 3. 添加剖分方案记录
 */
class OptimizedTriangulation {
private:
    int n;
    vector<Point> vertices;
    vector<vector<double>> dist;  // 预计算的距离矩阵
    vector<vector<double>> dp;
    vector<vector<int>> split;    // 记录分割点
    
    // 预计算所有点对距离
    void precomputeDistances() {
        dist.assign(n, vector<double>(n, 0));
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                double dx = vertices[i].x - vertices[j].x;
                double dy = vertices[i].y - vertices[j].y;
                dist[i][j] = dist[j][i] = sqrt(dx * dx + dy * dy);
            }
        }
    }
    
    // 快速计算三角形周长
    inline double triangleWeight(int i, int j, int k) {
        return dist[i][j] + dist[j][k] + dist[k][i];
    }
    
public:
    OptimizedTriangulation(const vector<Point>& verts) 
        : vertices(verts), n(verts.size()) {
        precomputeDistances();
        dp.assign(n, vector<double>(n, 0));
        split.assign(n, vector<int>(n, -1));
    }
    
    // 计算最优剖分值
    double compute() {
        if (n < 3) return 0;
        
        // 按长度递增计算
        for (int len = 2; len < n; len++) {
            for (int i = 0; i + len < n; i++) {
                int j = i + len;
                
                if (len == 2) {  // 三角形
                    dp[i][j] = triangleWeight(i, i+1, j);
                    split[i][j] = i + 1;
                } 
                else {  // 多边形
                    dp[i][j] = numeric_limits<double>::max();
                    
                    // 优化：从中间开始尝试
                    int startK = i + 1;
                    int endK = j;
                    
                    for (int k = startK; k < endK; k++) {
                        double left = (k - i >= 2) ? dp[i][k] : 0;
                        double right = (j - k >= 2) ? dp[k][j] : 0;
                        double current = left + right + triangleWeight(i, k, j);
                        
                        if (current < dp[i][j]) {
                            dp[i][j] = current;
                            split[i][j] = k;
                        }
                    }
                }
            }
        }
        
        return dp[0][n-1];
    }
    
    // 打印剖分方案
    void printTriangulation() {
        cout << "最优剖分方案：" << endl;
        printRecursive(0, n-1);
    }
    
private:
    void printRecursive(int i, int j) {
        if (j - i < 2) return;
        
        int k = split[i][j];
        if (k == -1) return;
        
        if (k - i >= 1 && j - k >= 1) {
            cout << "三角形: v" << i << "-v" << k << "-v" << j << endl;
        }
        
        if (k - i >= 2) {
            printRecursive(i, k);
        }
        if (j - k >= 2) {
            printRecursive(k, j);
        }
    }
};

// 验证多边形是否是凸的
bool isConvexPolygon(const vector<Point>& vertices) {
    int n = vertices.size();
    if (n < 3) return false;
    
    int sign = 0;
    for (int i = 0; i < n; i++) {
        Point p1 = vertices[i];
        Point p2 = vertices[(i+1)%n];
        Point p3 = vertices[(i+2)%n];
        
        double cross = (p2.x - p1.x) * (p3.y - p2.y) - 
                      (p2.y - p1.y) * (p3.x - p2.x);
        
        if (cross != 0) {
            if (sign == 0) {
                sign = cross > 0 ? 1 : -1;
            } else if (sign * cross < 0) {
                return false;
            }
        }
    }
    return true;
}

int main() {
    cout << "========== 最优三角剖分 - 优化版本 ==========" << endl;
    cout << "优化：预计算距离 + 记录剖分方案" << endl << endl;
    
    // 测试数据1：四边形
    {
        cout << "\n测试1：四边形" << endl;
        vector<Point> quad = {
            Point(0, 0),
            Point(5, 0),
            Point(6, 3),
            Point(2, 4)
        };
        
        if (!isConvexPolygon(quad)) {
            cout << "错误：多边形不是凸的！" << endl;
            return 1;
        }
        
        cout << "顶点: ";
        for (int i = 0; i < quad.size(); i++) {
            quad[i].print();
            cout << " ";
        }
        cout << endl;
        
        OptimizedTriangulation ot(quad);
        double result = ot.compute();
        cout << "最小总周长: " << fixed << setprecision(2) << result << endl;
        ot.printTriangulation();
    }
    
    // 测试数据2：正六边形
    {
        cout << "\n测试2：正六边形（半径为5）" << endl;
        vector<Point> hexagon;
        int sides = 6;
        double radius = 5.0;
        
        for (int i = 0; i < sides; i++) {
            double angle = 2 * M_PI * i / sides;
            hexagon.push_back(Point(
                radius * cos(angle),
                radius * sin(angle)
            ));
        }
        
        cout << "顶点坐标: " << endl;
        for (int i = 0; i < hexagon.size(); i++) {
            cout << "v" << i << ": ";
            hexagon[i].print();
            cout << endl;
        }
        
        OptimizedTriangulation ot(hexagon);
        double result = ot.compute();
        cout << "最小总周长: " << fixed << setprecision(2) << result << endl;
        ot.printTriangulation();
    }
    
    // 测试数据3：不规则七边形
    {
        cout << "\n测试3：不规则七边形" << endl;
        vector<Point> heptagon = {
            Point(0, 0),
            Point(4, 0),
            Point(6, 2),
            Point(5, 5),
            Point(3, 6),
            Point(1, 5),
            Point(-1, 2)
        };
        
        cout << "顶点: ";
        for (int i = 0; i < heptagon.size(); i++) {
            cout << "v" << i << "=";
            heptagon[i].print();
            cout << " ";
        }
        cout << endl;
        
        OptimizedTriangulation ot(heptagon);
        double result = ot.compute();
        cout << "最小总周长: " << fixed << setprecision(2) << result << endl;
        ot.printTriangulation();
    }
    
    // 性能对比
    {
        cout << "\n========== 性能对比 ==========" << endl;
        vector<Point> largePolygon;
        int sides = 10;
        
        // 生成随机凸多边形
        for (int i = 0; i < sides; i++) {
            double angle = 2 * M_PI * i / sides;
            double radius = 5 + (rand() % 100) / 100.0;  // 添加一些随机性
            largePolygon.push_back(Point(
                radius * cos(angle),
                radius * sin(angle)
            ));
        }
        
        cout << "测试" << sides << "边形..." << endl;
        
        clock_t start, end;
        
        // 基础版本
        start = clock();
        double basicResult = basicTriangulation(largePolygon);
        end = clock();
        double basicTime = double(end - start) / CLOCKS_PER_SEC;
        
        // 优化版本
        start = clock();
        OptimizedTriangulation ot(largePolygon);
        double optResult = ot.compute();
        end = clock();
        double optTime = double(end - start) / CLOCKS_PER_SEC;
        
        cout << fixed << setprecision(2);
        cout << "基础版本: " << basicResult << " (时间: " << basicTime << "秒)" << endl;
        cout << "优化版本: " << optResult << " (时间: " << optTime << "秒)" << endl;
        cout << "优化倍数: " << basicTime / optTime << "倍" << endl;
    }
    
    return 0;
}

7. 总结与实战建议

7.1 核心要点回顾

适用场景：凸多边形分割、图形处理、CAD设计
算法核心：区间动态规划
时间复杂度：O(n³)，可优化到O(n²)（四边形优化）
空间复杂度：O(n²)

7.2 实战建议

预处理很重要：确保多边形是凸的，顶点有序
权值函数选择：根据实际问题定制合适的权值
精度处理：几何计算注意浮点误差
代码优化：预计算、内存优化、循环优化

7.3 常见问题解答

Q: 如何处理非凸多边形？

A: 先进行凸分解，或者使用更复杂的算法

Q: 权值函数可以任意定义吗？

A: 只要满足四边形不等式，就可以用优化的DP算法

Q: 如何获取具体的剖分方案？

A: 记录分割点，递归重建

7.4 学习资源

《算法导论》第15章 - 动态规划
《计算几何：算法与应用》
LeetCode相关题目

希望这篇详细的技术文档能帮助你深入理解最优三角剖分问题！在实际应用中，多思考、多实践、多优化，你会掌握这个强大的算法工具。