Training Plan

Training Plan

https://www.nowcoder.com/acm/contest/12/F

题目描述

小Q同学为了准备今年的ICPC Regional，计划在m天之内刷掉n道题，每道题有一个难度值，其中第i道题的难度值为a[i]。
然而处于半颓废状态中的小Q同学不希望在同一天中做难度差距悬殊的题目，定义第i天中刷的题的难度的最大值减最小值为d[i]（如果第i天没有刷题，则d[i]=0），那么整个计划的难度为。
小Q同学可以按照任意的顺序刷题，并且一天中可以刷任意多道题，但是每道题只需要做一次，现在小Q同学想知道完成这个计划的总难度的最小值是多少。

输入描述:

第一行是一个正整数T(≤ 10)，表示测试数据的组数，
对于每组测试数据，
第一行是两个整数n(1≤ n ≤ 500)和m(1≤ m ≤ 500)，表示题数和天数，
第二行是n个整数a[i](0≤ a[i]≤ 1000000)，表示每道题的难度值。

输出描述:

对于每组测试数据，输出一个整数，表示整个计划的最小难度。

示例1

输入

2
3 3
1 2 3
3 2
1 2 3

输出

0
1

说明

对于第一组样例，最优方案是一天刷一题。
对于第二组样例，一个最优方案是第一天刷难度值为1和2的题，第二天刷难度值为3的题。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<climits>

using namespace std ; 

#define maxn 505
#define LL long long
LL num[maxn][maxn] ; 

int n , m ; 
int t ; 
LL a[maxn] ; 
LL dp[maxn][maxn] ; 


int main(){
        
    scanf("%d" , &t) ; 
    
    for(int i=1 ;i<=t ; i++){
        scanf("%d%d" , &n , &m) ; 
        
        
        for(int i=1 ; i<= n ; i++){
            scanf("%d" , &a[i]) ;  
        } 
        sort(a+1 , a+n+1) ; 
        memset(dp , 0 , sizeof(dp)) ; 
        
        for(int j=1 ; j<=n ; j++){
            dp[1][j] = (a[j] - a[1])*(a[j]-a[1]) ; 
        }

        for(int j=2 ; j<=m ; j++){
            for(int k=1 ; k<=n ; k++){
                dp[j][k] = 10000000000000007 ; 
                for(int L = 1 ; L < k ; L++){
                    dp[j][k] = min(dp[j][k] , dp[j-1][L]+(a[k]-a[L+1])*(a[k]-a[L+1])) ; 
                }
            }
        }
        
        printf("%lld\n" , dp[m][n]) ; 
    }
    
    
    return 0 ; 
}

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
long long a[510], dp[510][510];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
       int m, n;
       scanf("%d %d",&n, &m);
        
       for(int i=1; i<=n; i++)
          scanf("%lld",&a[i]);
        
       sort(a+1, a+n+1);
        
       if(n <= m)
       {
           printf("0\n");
           continue;
       }
        
       memset(dp, 0, sizeof(dp));
        
       for(int i=1; i<=n; i++)
       dp[1][i] = (a[i] - a[1]) * (a[i] - a[1]);
       
       for(int i=2; i<=m; i++)
         {     
            for(int j=i+1; j<=n; j++)
               {
                     dp[i][j] = 1000000000000007;
                     
                  for(int k=i-1; k<=j; k++)
                  {
                       dp[i][j] = min(dp[i][j], dp[i-1][k] + (a[j] - a[k+1]) * (a[j] - a[k+1]));
                  }
               }
         }
       
       printf("%lld\n",dp[m][n]);
    }
    return 0;
}