做到現在能一眼看出來是區間DP的問題了

也能夠知道dp[i][j]表示前  i  個節點被分為  j  個區間所取得的最優值的情況

cost[i][j]表示從i到j元素區間中的值，這裡可以直接排序後簡單求出——也就是我們的代價函式

這樣其實就能夠做出來了，但是空間複雜度是n3入門的題能過，普通點的都會考察你一下斜率DP的優化和四邊形不等式的優化。目前我主要就懂了平行四邊形的優化

首先你要確保dp和cost這兩個都滿足四邊形不等式這個前面有過證明的部落格這裡就簡單一提。

（部落格園真的好棒，自動儲存的，剛剛不小心全關了...）

（ a < b <= c< d ）

f[a][c]+f[b][d]<=f[b][c]+f[a][d]

這類不等式的滿足就可以證明出決策函式s[i][j]滿足上一等式——————決策函式s[i][j]表示dp[i][j]取得最優值時的k值，也就是把前 i 個分成 j 個區間 化為前 k 個分為 j - 1個區間留下一個區間 k +1  --- i這類問題，最優值k取s[i][j]

所以這個不等式就可以利用DP的層層遞推性，來縮小k的遍歷範圍如下

i< i+1<=j< j+1

那麼我                   s[i][j-1]<=s[i][j]<=s[i+1][j]

所以對於我們的遍歷j應該是正序的i應該是逆序的這樣才能層層推嘛，對於決策函式的初始化

s[i][i] = i前i個分成i段的最優值怎麼分都可以但是為了縮小範圍所以取  i  更合適

s[i][1]  吧前i個元素，分成1個區間那麼k的取值就是0呢

s[n+1][j] n + 1是 i越界的情況，可以看上面的決策函式的不等式，i+1是完全有越界的情況出現的，所以對於越界的情況我們統一賦值n也就是k的最大取值了

做了這種處理之後，剩下的就ojbk了，加油

這些東西昨天怎麼想都想不出來，睡了一家，今天路上一想就通了，好不奇怪，所以不要太心急，追求效率是應該的但也要追求記憶時間額的效率呢，加油ACMer！

#include <iostream>
#include <cstdio>
#include <string.h>
#include <algorithm>
#define inf (1 << 30)
using namespace std;
const int maxn = 1e4 + 10;
const int maxm = 5e3 + 10;
int dp[maxn][maxm];
//dp[i][j]把前i個數分為j個集合所得到的最優值
int s[maxn][maxm];
//dp[i][j]的前面的狀態
int a[maxn];
void init()
{
    memset(dp,0,sizeof(dp));
    memset(s,0,sizeof(s));
}
int getval(int l,int r)
{
    return (a[r] - a[l]) * (a[r] - a[l]);
}
int main()
{
    int t,n,m;
    scanf("%d",&t);
    int cas = 0;
    while(t--)
    {
        scanf("%d%d",&n,&m);
        init();
        for(int i = 1;i <= n;i++)
        {
            scanf("%d",&a[i]);
        }
        sort(a+1,a+1+n);
        //用s[i][j]表示dp[i][j]取得最優解的時候k的位置的話
        //用s[i][j]來表示選dp[i][j]的最佳選擇然後s[i-1][j]<=s[i][j]<=s[i][j+1]

        for(int i = 1;i <= n;i++)
        {
            dp[i][1] = getval(1,i);
            dp[i][i] = 0;
            s[i][i] = i;
            s[i][1] = 0;
        }

        for(int j = 2;j <= m;j++)
        {
            s[n+1][j] = n ;//越界情況
            for(int i = n;i >= j;i--)
            {
                dp[i][j] = inf;
                for(int k = s[i][j-1];k <= s[i+1][j];k++)
                {
                    if(dp[i][j] > dp[k][j-1] + getval(k+1,i))
                    {
                        dp[i][j] = dp[k][j-1] + getval(k+1,i);
                        s[i][j] = k;
                    }
                }
            }
        }
        printf("Case %d: %d\n",++cas,dp[n][m]);
    }
    return 0;
}
 

 嗯嗯自己寫的吧，演算法有很大的優化空間，時間消耗過大，險過

而且空間佔用很大，就模擬大佬的程式碼學習了一下滾動陣列，優化空間

空間消耗過大，滾動陣列
滾動陣列一般在DP題和狀態壓縮演算法方面用的多，而且優化後效率很高，推薦使用。
對什麼可以滾動呢？？
一共就兩個東西，一個是分為區間數，一個是元素的個數、
咋一眼也就知道分的區間數應該是能滾動的，元素個數沒什麼好的想法
說明白一點，先看看原來沒有滾動的版本
dp[i][j] > dp[k][j-1] + getval(k+1,i)
i是元素個數的限制
j是分的區間個數的限制
你看到k是要遍歷的，也就是元素個數是不能壓縮的，滾動陣列要具備的條件就是，他一次
只用部分值，很少一部分，然後我們可以滾動儲存
所以看看j，劃分的區間個數，在進行更新時好像只和j-1有關呢
哈哈，空間為2的滾動陣列出來了

#include <cstdio>
#include <string.h>
#include <algorithm>
#include <iostream>
#define inf (1<<30)
using namespace std;

const int maxn = 1e4 +10;
const int maxm = 1e3 + 10;
int dp[2][maxn];//這裡問題不一樣了第一維是分的區間個數，第二維是元素個數

int s[2][maxn];
int a[maxn];

int n,m;

void init()
{
    for(int i = 1;i <= n;i++)
        scanf("%d",&a[i]);
    sort(a+1,a+1+n);

    for(int i = 1;i <= n;i++)
    {
        dp[1%2][i] = (a[i] - a[1]) * (a[i] - a[1]);
        s[1%2][i] = 0;
    }
}
void solve()
{
    for(int i = 2;i <= m;i++)
    {
        s[i%2][n+1] = n;
        for(int j = n;j > i;j--)
        {
            dp[i % 2][j] = inf;
            for(int k = s[(i-1)%2][j];k <= s[i%2][j+1];k++)
            {
                if(dp[(i-1) % 2][k] + (a[j] - a[k+1]) * (a[j] - a[k+1]) < dp[i%2][j])
                {
                    dp[i%2][j] = dp[(i-1) % 2][k] + (a[j] - a[k+1]) * (a[j] - a[k+1]);
                    s[i % 2][j] = k;
                }
            }
        }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    for(int ca = 1; ca <= t;ca++)
    {
        scanf("%d%d",&n,&m);
        init();
        solve();
        printf("Case %d: %d\n",ca,dp[m%2][n]);
    }
    return 0;
}

 然後大佬的演算法時間消耗也少，真的是很不錯，而且dp的維度徵好和我的相反