一类斜率优化的dp（特有性质：只能连续，不能交叉）

hdu3480

给定一个有n个数的集合，将这个集合分成m个子集，要求子集的并等于全集
求花费最小。

花费为该子集的（最大数-最小数）的平方。

我们将n个数排序，

a < b < c < d

那么不可能a,c一个集合，b,c一个集合

明显a,b一个集合，c,d一个集合更优

也就是说某一个数只能和它前面的连续几个数合起来形成一个子集。 正是因为有这个性质才能dp

dp[i][j]表示第j个数在第i个集合的最小花费

dp[i][j] = min(dp[i][j],dp[i-1][k]) 1<=k<j

dp[i-1][k1] + (a[j]-a[k1+1])^2 < dp[i-1][k2]+(a[j]-a[k2+1])^2

dp[i-1][k1]+a[k1]^2-(dp[i-1][k2]+a[k2]^2) < 2a[j]*(a[k1+1]-a[k2+1])

这样就能够用斜率优化了，由于是求最小值，所以维护一个下凸包就行了。

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <iostream>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <map>
 #include <set>
 #include <string>
 #include <math.h>
 using namespace std;
 #pragma warning(disable:4996)
 #pragma comment(linker, "/STACK:1024000000,1024000000")
 typedef int LL;
 const int INF = <<;
 /*
 给定一个有n个数的集合，将这个集合分成m个子集，要求子集的并等于全集
 求花费最小，  花费为什么每个集合的（最大值-最小值）的平方

 dp[i][j]表示第j个数在第i个集合的最小花费
 用滚动数组压缩空间
 */

 const int N =  + ;
 const int M =  + ;
 LL a[N];
 LL dp[][N];
 int q[N], head, tail;
 LL dw(LL a, LL b)
 {
     return (a - b)*(a - b);
 }
 LL getUp(int k1, int k2, int c)
 {
     return dp[c][k1] + a[k1 + ] * a[k1 + ] - (dp[c][k2] + a[k2 + ] * a[k2 + ]);
 }
 LL getDown(int k1, int k2)
 {
     return  * (a[k1 + ] - a[k2 + ]);
 }
 int main()
 {
     int t, n, m;
     scanf("%d", &t);
     for (int k = ; k <= t; ++k)
     {
         scanf("%d%d", &n, &m);
         for (int i = ; i <= n; ++i)
             scanf("%d", &a[i]);
         sort(a + , a + n + );
         n = unique(a + , a + n + ) - a - ;
         if (m > n)
             m = n;
         int c = ;
         for (int j = ; j <= n; ++j)
             dp[][j] = dw(a[j], a[]);
         for (int i = ; i <= m; ++i)
         {
             head = tail = ;
             for (int j = i; j <= n; ++j)
             {
                 while (head + < tail && getUp(j - , q[tail - ], c)*getDown(q[tail - ], q[tail - ])
                     <= getUp(q[tail - ], q[tail - ], c)*getDown(j - , q[tail - ]))
                     tail--;
                 q[tail++] = j - ;
                 while (head +  < tail&&getUp(q[head + ], q[head], c) < a[j] * getDown(q[head+], q[head]))
                     head++;
                 dp[c ^ ][j] = dp[c][q[head]] + dw(a[j], a[q[head] + ]);
             }
             c ^= ;
         }
         printf("Case %d: %d\n",k, dp[c][n]);
     }
     return ;
 }

hdu3405

n头牛，分成几组，每组至少有k头牛
要求费用最小，

费用是每组所有牛的moo，减去该组中最小的moo

将moo排序

那么如果是分成两组的话，那么不可能是a,c一组， b,d一组
a,b,一组比c，d一组肯定更优。
又遇到了有这种性质的题目， 连续比交叉更优，这样，才能用dp来解决，

dp[j]表示以j结尾的team的最小花费
(dp[k1]-sum[k1]+k1*moo[k1+1]) - (dp[k2]-sum[k2]+k2*moo[k2+1]) < i*(moo[k1+1]-moo[k2+1])
dp[k1]+k1*moo[k1+1] - (dp[k2]+k2*moo[k2+1]) < i * (moo[k1+1]-moo[k2+1])
所以维护递增的斜率

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <algorithm>
 #include <iostream>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <map>
 #include <set>
 #include <string>
 #include <math.h>
 using namespace std;
 #pragma warning(disable:4996)
 #pragma comment(linker, "/STACK:1024000000,1024000000")
 typedef __int64 LL;
 const int INF = <<;
 /*
 n头牛，分成几组，每组至少有k头牛
 要求费用最小，
 费用是每组所有牛的moo，减去该组中最小的moo
 a < b < c < d
 那么如果是分成两组的话，那么不可能是a,c一组， b,d一组
 a,b,一组比c，d一组肯定更优。
 又遇到了有这种性质的题目， 连续比交叉更优，这样，才能用dp来解决，
 dp[j]表示以j结尾的team的最小花费
 (dp[k1]-sum[k1]+k1*moo[k1+1]) - (dp[k2]-sum[k2]+k2*moo[k2+1]) < i*(moo[k1+1]-moo[k2+1])
 dp[k1]+k1*moo[k1+1] - (dp[k2]+k2*moo[k2+1]) < i * (moo[k1+1]-moo[k2+1])
 所以维护递增的斜率

 */
 const int N =  + ;
 LL moo[N], dp[N], sum[N];
 int q[N], head, tail;

 LL getUp(int k1, int k2)
 {
     return dp[k1] + k1*moo[k1 + ] - sum[k1] - (dp[k2] + k2*moo[k2 + ] - sum[k2]);
 }
 LL getDown(int k1, int k2)
 {
     return moo[k1 + ] - moo[k2 + ];
 }
 int main()
 {
     int n, t;
     while (scanf("%d%d", &n, &t) != EOF)
     {
         for (int i = ; i <= n; ++i)
         {
             scanf("%I64d", &moo[i]);
         }
         sort(moo + , moo + n + );
         for (int i = ; i <= n; ++i)
             sum[i] = moo[i] + sum[i - ];
         for (int i = t; i <= n; ++i)
             dp[i] = sum[i] - i*moo[];

         head = tail = ;
         q[tail++] = ;
         q[tail++] = t;
         int k = t + ;
         for (int i = *t; i <= n; ++i)
         {
             while (head +  < tail&&getUp(q[head + ], q[head]) < i*getDown(q[head + ], q[head]))
                 head++;
             dp[i] = dp[q[head]] + sum[i]-sum[q[head]] - (i-q[head])*moo[q[head] + ];
             while (head +  < tail&&getUp(k, q[tail - ])*getDown(q[tail - ], q[tail - ]) <= getUp(q[tail - ], q[tail - ])*getDown(k, q[tail - ]))
                 tail--;
             q[tail++] = k++;
         }
         printf("%I64d\n", dp[n]);
     }
     return ;
 }