2018 ACM-ICPC 中国大学生程序设计竞赛线上赛 D Merchandise (斜率优化)

Description:

The elderly aunts always like to look for bargains and preferential merchandise. Now there is a shop carrying out group purchase promotion.

Rules are as follows :

There are r pieces of promotional items, and each item is only one. In the group purchase, everyone will buy one at least and have to conform the rules if they want to enjoy the benefit :

All the merchandise at a prime number has to be purchased ;

the merchandise at non-prime number cannot be chosen ;

The amount of money that each person pays is the square of the difference between the maximum and minimum value of the product he or she chooses. Notice that there may be several merchandises having the same price.

(If a person buys only one item, follow the rules and spend ￥ 0.00)

Assume that there are m people in a group, and everyone should enjoy the benefit.  Please arrange each person's choice of merchandise reasonably, so that the sum of money paid by m people can be the minimum.

The number of merchandise with a price of prime is n，m<=n , n<=5000

Input:

The input contains multiple test cases.

In the first line of the input there’s an integer T which is the number of test cases. Then the description of T test cases will be given.

For any test case, the first line of input consists of two separated integers r and m.

（0<r<=100000,0<m<=1000)

The second line should consists of r space separated integers k1,k2...kr.

(1<ki<2^16,1<=i<=r)

ki represents the price of one item

Output:

Print one integer sum (sum<2^32)——the minimum number of money paid by m people.

忽略每行输出的末尾多余空格

样例输入

1
6 2
5 6 10 2 11 3 

样例输出

9

题意：给你r个数，首先你要跳出其中的所有的素数(n<=5000)，然后将这些素数分成m(<=n)个组。
每个组的权值为（这个组中最大元素-这个组最小元素）^2，问各组的权值的和最小为多少
思路：
首先我们想到先排序然后dp
先写转移方程，我们设dp[i][j]为前i个数分为j个集合的权值的和，则有

还有j那维需要循环，这个复杂度为n^3，显然是超时的。我们利用斜率优化算法优化成n^2的
将上面等式右边{}内的看成关于自变量k的一个函数val(k)
将k1带入得到

将k看成变量，分离变量与常量整理上式。


这个式子就像一个直线的方程，我们的目的是让dp[i][j]最小即截距dp[i][j]+a[i]^2最小
这个直线的斜率是2*a[i]，也就是说坐标轴上有好多点，每个具体的k都确定一个点(a[k],dp[k-1][j-1]+a[k]^2)
我们转化成了一个线性规划问题，假设当前有好几个点，我们只需要维护他们是下凸的就行了
即如果有三个连续的点k1,k2,k3，那么斜率(k2,k1)<斜率(k2,k3)
这个我们用单调队列维护。这样就能减少复杂度
代码如下：

 #include <bits/stdc++.h>

 using namespace std;
 typedef long long ll;
 const ll inf = 1e18;
 const int maxn = 5e5+;
 const int maxm = ;
 const int maxp = (<<)+;
 bool check (int x){
     for (int i=;i*i<=x;++i){
         if (x%i==)
             return false;
     }
     return true;
 }
 int prime[maxp];//保存素数
 bool vis[maxp];
 int r,n,m;
 ll a[maxn],b[maxm];
 ll dp[maxm][maxm];
 int q[maxm];
 int head,tail;
 void  getprime(int n)
 {
     int cnt = ;
     memset(vis,,sizeof(vis));
     for(int i=;i<n;i++)
     {
         if(!vis[i])
         prime[cnt++]=i;
         for(int j=;j<cnt&&i*prime[j]<n;j++)
         {
             vis[i*prime[j]]=;
             if(i%prime[j]==)
             break;
         }
     }
     return ;
 }
 int main()
 {
     int t;
     getprime(maxp);
     //freopen("de.txt","r",stdin);
     scanf("%d",&t);
     dp[][]=;
     for (int i=;i<maxm;++i)
         dp[i][]=inf;
     while (t--){
         n = ;
         ll x;
         scanf("%d%d",&r,&m);
         for (int i=;i<r;++i){
             scanf("%lld",&x);
             if (!vis[x]){
                 a[++n] = x;
             }
         }
         sort(a+,a+n+);
         for (int i=;i<=n;++i){
             b[i] = a[i]*a[i];
         }
         for (int j=;j<=m;++j){
             head = ,tail = ;
             dp[][j]=inf;
             for (int i=;i<=n;++i){
                 while (tail-head>=){
                     int x=q[tail-],y=q[tail-];
                     double v1,v2;
                     if (a[y]==a[x]) v1 = inf;
                     else v1=(dp[y-][j-]+b[y]-dp[x-][j-]-b[x])/(2.0*(a[y]-a[x]));
                     if (a[y]==a[i]) v2 = inf;
                     else v2=(dp[i-][j-]+b[i]-dp[y-][j-]-b[y])/(2.0*(a[i]-a[y]));
                     if (v1>v2)
                         tail--;
                     else
                         break;
                 }
                 q[tail++] = i;
                 while (tail-head>=){
                     int x=q[head],y=q[head+];
                     double v1;
                     if (a[y]==a[x]) v1 = inf;
                     else v1=(dp[y-][j-]+b[y]-dp[x-][j-]-b[x])/(2.0*(a[y]-a[x]));
                     if (v1<a[i])
                         head++;
                     else
                         break;
                 }
                 int tmp = q[head];
                 dp[i][j] = dp[tmp-][j-]+(ll)(a[i]-a[tmp])*(ll)(a[i]-a[tmp]);
                 //printf("%lld %d %d\n",dp[i][j],i,j);
             }
         }
         printf("%lld\n",dp[n][m]);
     }
     return ;
 }