#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>

using namespace std;

#define INF 100000000000;

int compare(const int &a, const int &b)
{
    if(a <= b) return 1;
    else return 0;
}

void printArr(vector<double>& arr)
{
    cout << "[";
    for(int i=0;i<arr.size();i++)
        cout << arr[i] << " ";
    cout << "]" << endl;
}
void printArr1(vector<int>& arr)
{
    cout << "[";
    for(int i=0;i<arr.size();i++)
        cout << arr[i] << " ";
    cout << "]" << endl;
}

int getLowest(vector<double> &group)
{
    double value = INF;
    int ret = -1;
    for(int i=0;i<group.size()-1;i++)
    {
        if(group[i] == group[i+1])
            return i;
        if(value > group[i+1]-group[i])
        {
            value = group[i+1]-group[i];
            ret = i;
        }
    }
    return ret;
}

void mergeGroup(vector<double> &group, vector<int> &elem_cnt, int index)
{
    int elem = group[index+1];
    int cnt = elem_cnt[index+1];

//    cout << "elem=" << elem << ",cnt="<< cnt << endl;
    group[index] = group[index]*elem_cnt[index] + elem*cnt;
    elem_cnt[index] += elem_cnt[index+1];

    group[index] /= elem_cnt[index];
    group.erase(group.begin()+index+1);
    elem_cnt.erase(elem_cnt.begin()+index+1);
}

int calculate(vector<int> &arr, vector<double>& group, vector<int>&elem_cnt)
{

    printArr(group);
    printArr1(elem_cnt);
    int ret = 0;
    int j=0;
    for(int i=0;i<arr.size();i++)
    {
        if(elem_cnt[j] == 0)
            j++;


        if(group[j] - (int)group[j] > 0.5)
            group[j] = (int)group[j] + 1;
        else group[j] = (int)group[j];

        cout <<"ret=" << ret ;
        cout <<", arr["<<i<<"]=" << arr[i] ;
        cout <<", group["<<j<<"]=" << (int)group[j];
        cout <<", pow(arr[i]+group[j],2)=" << pow(arr[i] - (int)group[j], 2) ;
        cout <<", ret + pow(arr[i]+group[j])=" << ret + pow(arr[i] - (int)group[j], 2)<<endl;
        ret += pow(arr[i] - (int)group[j], 2);

        elem_cnt[j]--;
    }
    return ret;
}

int quantization(vector<int> &arr, int groupSize)
{
    vector<double> group;
    vector<int> elem_cnt;

    stable_sort(arr.begin(),arr.end(),compare);
    //printArr1(arr);

    for(int i=0;i<arr.size();i++)
    {
        group.push_back((double)arr[i]);
        elem_cnt.push_back(1);

        if( group.size() > groupSize)
        {
            int index = getLowest(group);

            mergeGroup(group,elem_cnt,index);
        }
    }

    return calculate(arr,group,elem_cnt);
}


int main()
{


    int num;
    int arrSize;
    int testcase;
    int groupSize;
    vector<int> arr;

    cin >> testcase;

    while(testcase--)
    {
        cin >> arrSize >> groupSize;

        for(int i=0;i<arrSize;i++)
        {
            cin >> num;
            arr.push_back(num);
        }

        cout << quantization(arr,groupSize) <<endl;

        arr.clear();
    }
    return 0;
}