import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws NumberFormatException, IOException {
        // TODO Auto-generated method stub
        BufferedReader rb = new BufferedReader(new InputStreamReader(System.in));
        int testNum = Integer.parseInt(rb.readLine());

        for (int t = 0; t < testNum; t++) {
            StringTokenizer token = new StringTokenizer(rb.readLine());
            int arr[] = new int[Integer.parseInt(token.nextToken())];
            int quantNum = Integer.parseInt(token.nextToken());

            token = new StringTokenizer(rb.readLine());
            for (int i = 0; i < arr.length; i++) {
                arr[i] = Integer.parseInt(token.nextToken());

            }

            Quantization quantization = new Quantization(arr);
            System.out.println(quantization.quantize(0, quantNum));
        }
    }
}

//양자화를 할 때 
class Quantization {
    int[] arr;
    // x 위치에서 y길이만큼 값을 설정 했을 때 결과 값
    int[][] cache = new int[101][11];

    public Quantization(int[] arr) {
        this.arr = arr;
        for (int i = 0; i < cache.length; i++) {
            Arrays.fill(cache[i], -1);
        }
        Arrays.sort(this.arr);
    }

    // 분할 개수
    int quantize(int start, int quant) {

        if (cache[start][quant] != -1) {
            return cache[start][quant];
        }
        // 양자수보다 남은 길이가 더 적을 때 모든 양자화 완료
        if (arr.length - start <= quant) {
            return 0;
        }
        // 양자화 수가 한개 남았을 때 계산
        if (quant == 1) {
            return getMinError(start, arr.length - start);
        }
        //일정량 양자화 후 남은 길이,양자화가능수 재귀호출
        int ret = Integer.MAX_VALUE;
        for (int i = start + 1; i <= arr.length - quant; i++) {
            int len = i - start;
            ret = Math.min(ret, getMinError(start, len) + quantize(i, quant - 1));
        }

        cache[start][quant] = ret;
        return ret;
    }

    // 양자화 결과값 리턴
    // start : 시작위치
    // size : 범위
    int getMinError(int start, int size) {
        int aver = 0;
        for (int i = start; i < start + size; i++) {
            aver += arr[i];
        }
        aver /= size;
        int averRet = 0;
        for (int i = start; i < start + size; i++) {
            averRet += Math.pow(Math.abs(arr[i] - aver), 2);
        }
        int aver1Ret = 0;
        for (int i = start; i < start + size; i++) {
            aver1Ret += Math.pow(Math.abs(arr[i] - (aver + 1)), 2);
        }
        return (averRet > aver1Ret) ? aver1Ret : averRet;
    }
}// end Quantization