AcWing 1069. 凸多边形的划分（区间dp 高精度加法 乘法）

题意：

给定 n 个点的 凸多边形 中每个 顶点 的 权值 wi
我们可以把该 凸多边形 划分成 n - 2 个 三角形（三角形不能相交，这样就能保证是 n−2 了）

每次划分三角形的 费用 为 三个顶点权值 的 乘积

求一个划分 方案，使得方案的 费用总和 最小

思路：（本题的分析思路与上一题不同，但是推导出的状态转移方程两者一致）

本题是一个给定的 凸多边形 求 三角剖分 的最小费用方案

很显然一个 凸多边形的剖分方案 并不唯一：

在 选定 多边形中 两个点 后，找出 三角形 的 第三个点 的方案有 n−2 个

然后还要分别 划分 左右两块区域

因此我们就会想到用 记忆化搜索 或者 区间DP 来进行处理

本题采用 区间DP 的方式进行求解，下面进行分析

dp[l,r] 状态表示

集合：所有当前划分到的多边形的 左端点是 l，右端点是 r 的方案

属性：方案的最小费用

dp[l,r] 状态计算

$fl,r=min(fl,k+fk,r+wl\times wk\times wr)(l<k<r)$

区间DP 在状态计算的时候一定要 认真 划分好 边界 和 转移，对于不同题目是不一样的

然后本题数据非常卡，直接用样例的 5 的点告诉我们答案会爆 $int$ 和 $longlong$

并且没有 取模 要求，那就只能上 高精度 了（当然如果OJ允许的话还可以直接使用**__int28**）

代码：

#pragma GCC optimize(2)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
typedef vector<ll> vll;
#define pb push_back
#define pp pop_back

const int N = 55, M = 35;

vll dp[N][N];
int w[N];
int n;

vll add(vll &a, vll &b)
{
    vll sum; int t = 0;
    for(int i=0; i<a.size()||i<b.size()||t; ++i)
    {
        if(i<a.size()) t+=a[i];
        if(i<b.size()) t+=b[i];
        sum.pb(t%10);
        t/=10;
    }

    return sum;
}

vll mul(vll &a, int b)
{
    ll t = 0; vll res;
    for(int i=0; i<a.size()||t; ++i)
    {
        if(i<a.size()) t += (ll)a[i]*b;
        res.pb(t%10);
        t /= 10;
    }while(res.size()>1&&!res.back()) res.pp();
    return res;
}

vll min(vll& a, vll& b)//重载min函数，使之返回两个高精度数中较小者
{
    if(a.size() > b.size()) return b;
    else if(a.size()==b.size())
    {
        for(int i=a.size()-1; i>=0; --i)
            if(a[i] != b[i]) return a[i] > b[i] ? b : a;
        return b;
    }
    else return a;
}

void print(vll dp)
{
    for(int i=dp.size()-1; i>=0; --i) cout<<dp[i];
    puts("");
}

int main()
{
    cin>>n;
    for(int i=1; i<=n; ++i) cin>>w[i];
    //区间长度为3(三条边)才能构成一个三角形,
    for(int len=3; len<=n; ++len)
    {
        for (int l=1; l+len-1<=n; ++l)
        {
            int r = l + len - 1;
            //枚举两个区间之间的分割线构成两个区间和一个三角形,范围是[l + 1,r - 1]
            
            //dp[l][r] = INF;
            dp[l][r] = vll(M, 9);//相当于设置dp[l][r]为正无穷
            for (int k=l+1; k<r; ++k)
            {
                vll tmp; tmp.pb(w[l]);
                tmp = mul(tmp, w[k]), tmp = mul(tmp, w[r]);
                tmp = add(tmp, dp[l][k]), tmp = add(tmp, dp[k][r]);
                //dp[l][r] = min(dp[l][r],dp[l][k] + dp[k][r] + w[l] * w[k] * w[r]);
                dp[l][r] = min(dp[l][r], tmp);
            }
        }
    }
    
    print(dp[1][n]);
    
    return 0;
}