#include <iostream>
#include <vector>
#include <algorithm>
#include <tuple>

using namespace std;

int obvio(vector<pair<unsigned,unsigned>> saltos, unsigned k, unsigned n){
	if(k==1){return 0;}
	unsigned t = saltos.size();
	unsigned abajo=0 , arriba=0, medio=0, sumaAbajo = saltos[0].second, sumaArriba = saltos[t-1].second;
	bool bandera =false;

	unsigned i=1;
	while(sumaAbajo<k){
		abajo += sumaAbajo*(saltos[i].first-saltos[i-1].first);
		sumaAbajo += saltos[i].second;
		i++;
	}
	abajo -= (sumaAbajo-k);
	i=1;
	while(sumaArriba<k){
		arriba += sumaArriba*(saltos[t-i].first-saltos[t-i-1].first);
		sumaArriba += saltos[t-1-i].second;
		i++;
	}
	arriba -= (sumaArriba-k);
	if(2*saltos[0].second < n && 2*saltos[t-1].second < n && 2*k > n){
		bandera =true;
		unsigned sumaMedAbajo=saltos[0].second, sumaMedArriba=saltos[t-1].second;
		i=1;
		while(2*(sumaMedAbajo)<n && 2*(sumaMedArriba)<n){
			medio += sumaMedAbajo*(saltos[i].first-saltos[i-1].first);
			sumaMedAbajo += saltos[i].second;
			medio += sumaMedArriba*(saltos[t-i].first-saltos[t-i-1].first);
			sumaMedArriba += saltos[t-1-i].second;
			i++;
		}
		unsigned j=i;
		if(2*(sumaMedAbajo)>=n){
			while(i-1 <= t-1-j){
				medio += sumaMedArriba*(saltos[t-j].first-saltos[t-j-1].first);
				sumaMedArriba += saltos[t-1-j].second;
				j++;
			}
		}
		else{
			while(j-1 <= t-1-i){
				medio += sumaMedAbajo*(saltos[j].first-saltos[j-1].first);
				sumaMedAbajo += saltos[j].second;
				j++;
			}
		}
	medio -= (n-k);
	}
	if(bandera){
		if(medio <= abajo && medio <= arriba){return medio;}
		else{if(abajo<=arriba){return abajo;}
			else{return arriba;}}
	}
	if(abajo<=arriba){return abajo;}
	else{return arriba;}
}

tuple<int,int,int> operacionesDP(int k, vector<pair<unsigned,unsigned>> &saltos, int i , int j, int topeAbajo, int topeArriba, vector<vector<tuple<int,int,int,bool>>> &caja){
	if(get<3>(caja[i][j])){return make_tuple(get<0>(caja[i][j]),get<1>(caja[i][j]),get<2>(caja[i][j]));}
	int t = saltos.size();
	if (i==topeAbajo-1 || j==topeArriba-1 || i+j == t-1)
	{
		int sumaAbajo =0;
		for (int abcd = 0; abcd <= i ; abcd++)
		{
			sumaAbajo += saltos[abcd].second;
		}

		int sumaArriba = 0;
		for (int abcd = 0; abcd <= j ; abcd++)
		{
			sumaArriba += saltos[t-1-abcd].second;
		}

		if(i+j==t-1){caja[i][j] = make_tuple(k-sumaArriba-sumaAbajo+saltos[i].second,sumaAbajo/*+sumaArriba-saltos[i].second*/,sumaArriba/*+sumaAbajo-saltos[i].second*/,true);}
		else{if(i==topeAbajo-1){caja[i][j] = make_tuple(k-sumaAbajo,sumaAbajo,sumaArriba,true);}
		else{if(j==topeArriba-1){caja[i][j] = make_tuple(k-sumaArriba,sumaAbajo,sumaArriba,true);}}}
		//cout << i << ' ' << j << endl; // <<" caso inicial " << get<1>(caja[i][j]) << ' ' << get<2>(caja[i][j]) <<' ' << get<0>(caja[i][j]) << endl; //aca
		return make_tuple(get<0>(caja[i][j]),get<1>(caja[i][j]),get<2>(caja[i][j]));
	}
	tuple<int,int,int> operoAbajo = operacionesDP(k,saltos,i+1,j,topeAbajo,topeArriba,caja), operoArriba = operacionesDP(k,saltos,i,j+1,topeAbajo,topeArriba,caja);
	int opNecAbajo = (get<1>(operoAbajo)-saltos[i+1].second)*(saltos[i+1].first-saltos[i].first);
	int opNecArriba = (get<2>(operoArriba)-saltos[t-1-j-1].second)*(saltos[t-1-j].first-saltos[t-1-j-1].first);
	if(opNecAbajo + get<0>(operoAbajo) < opNecArriba + get<0>(operoArriba)){caja[i][j] = make_tuple(opNecAbajo + get<0>(operoAbajo),get<1>(operoAbajo)-saltos[i+1].second,get<2>(operoAbajo),true);}
	else{caja[i][j] = make_tuple(opNecArriba + get<0>(operoArriba),get<1>(operoArriba),get<2>(operoArriba)-saltos[t-1-j-1].second,true);}

	//cout << i << ' ' << j << endl;// <<' ' << get<1>(caja[i][j]) << ' ' << get<2>(caja[i][j]) <<' ' << get<0>(caja[i][j]) << endl; //aca
	return make_tuple(get<0>(caja[i][j]),get<1>(caja[i][j]),get<2>(caja[i][j]));
}

int ordenarSinDP(vector<int> a, int k){
	int n = a.size();
	vector<pair<int,int>> saltos(0);
	int ultimoSalto=-1;
	pair<int,int> bhsajd;
	for (int i = 1; i < n; i++)
	{
		if(a[i]!=a[i-1]){
			if(i-1-ultimoSalto >= k){return 0;};
			bhsajd = make_pair(a[i-1],i-1-ultimoSalto);
			saltos.push_back(bhsajd);
			ultimoSalto=i-1;
		}
	}
	if(n-1-ultimoSalto >= k){return 0;};
	bhsajd = make_pair(a[n-1],n-1-ultimoSalto);
	saltos.push_back(bhsajd);
	int t = saltos.size();
	if(t==1){return 0;}
	if(t==2){
		int d = saltos[1].first-saltos[0].first,
		abcd = saltos[0].second;
		if(2*abcd < n){return (d-1)*abcd+(k-(n-abcd));}
		else{return (d-1)*(n-abcd)+(k-abcd);}
	}
	int sumaAbajo =0, sumaArriba=0;
	int suma=0, suma2=0, topeAbajo=0, topeArriba=0;
	int limiteAbajo = n-saltos[t-1].second, limiteArriba = n-saltos[0].second;
	bool dosOperaciones = true;
	if (k<=limiteAbajo)
	{
		for (int i = 0; suma < k; i++)
		{
			suma += saltos[i].second;
			topeAbajo=i;
			if(i!=0){sumaAbajo +=(saltos[i].first-saltos[i-1].first)*(suma-saltos[i].second);}
		};
		if(topeAbajo!=0){sumaAbajo -= (suma-k);}
	}
	else
		{
			dosOperaciones = false;
			vector<int> I(t,0), S(t,0);
			for (int i = 1; i < t; i++)
			{
				suma += saltos[i-1].second;
				I[i] += suma*(saltos[i].first-saltos[i-1].first);
				I[i] += I[i-1];
			}
			for (int i = t-2; i >= 0 ;

			 i--)
			{
				suma2 += saltos[i+1].second;
				S[i] += suma2*(saltos[i+1].first-saltos[i].first);
				S[i] += S[i+1];
			}
			sumaAbajo = I[0]+S[0];
			for (int i = 0; i < t; i++)
			{
				if(sumaAbajo > I[i]+S[i]){sumaAbajo = I[i]+S[i];}
			}
			sumaAbajo -= (n-k);
		}
	suma=0; suma2=0;
	if(k<=limiteArriba)
	{
		for (int i = t-1; suma < k; i--) //aca reemplace t por n
		{
			suma += saltos[i].second;
			topeArriba=i;
			if(i!=t-1){sumaArriba +=(saltos[i+1].first-saltos[i].first)*(suma-saltos[i].second);} // aca tambien
		}
		if(topeArriba!=t-1){sumaArriba -= (suma-k);} //aca tambien
	}
	else
	{
		if(dosOperaciones){
			vector<int> I(t,0), S(t,0);
			for (int i = 1; i < t; i++)
			{
				suma += saltos[i-1].second;
				I[i] += suma*(saltos[i].first-saltos[i-1].first);
				I[i] += I[i-1];
			}
			for (int i = t-2; i >= 0 ; i--)
			{
				suma2 += saltos[i+1].second;
				S[i] += suma2*(saltos[i+1].first-saltos[i].first);
				S[i] += S[i+1];
			}
			sumaArriba = I[0]+S[0];
			for (int i = 0; i < t; i++)
			{
				if(sumaArriba > I[i]+S[i]){sumaArriba = I[i]+S[i];}
			}
			sumaArriba -= (n-k);
		}else{sumaArriba=sumaAbajo;}
	}
	if(sumaArriba<sumaAbajo){return sumaArriba;}
	else{return sumaAbajo;}

}

unsigned ordenarDP(unsigned &k, vector<pair<unsigned,unsigned>> &saltos, unsigned n){
	unsigned t= saltos.size();
	if(t==1){return 0;}
	/*for (unsigned i = 0; i < t; ++i)
	{
		if(saltos[i].second >= k){return 0;}
	}*/
	vector<pair<unsigned,unsigned>> b=saltos;
	unsigned operoArriba=0, operoAbajo=0;
	if (saltos[0].second+saltos[1].second < k)
	{
		if(2*(b[0].second+b[1].second) > n)
		{
			operoAbajo += b[0].second*(b[1].first-b[0].first);
			b[1].second += b[0].second;
			b.erase(b.begin());
		}
		while(b[0].second+b[1].second < k && 2*(b[0].second+b[1].second) <= n)
		{
			operoAbajo += b[0].second*(b[1].first-b[0].first);
			b[1].second += b[0].second;
			b.erase(b.begin());
		}
		operoAbajo += ordenarDP(k,b,n);
	}
	else
	{
		operoAbajo = saltos[0].second*(saltos[1].first-saltos[0].first);
		operoAbajo -= (saltos[0].second+saltos[1].second-k);
	}

	if (saltos[t-1].second+saltos[t-2].second < k)
	{
		if (2*(saltos[t-1].second+saltos[t-2].second) > n)
		{
			operoArriba += saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
			saltos[t-2].second += saltos[t-1].second;
			saltos.erase(saltos.end());
		}
		while(saltos[t-1].second+saltos[t-2].second < k && 2*(saltos[t-1].second+saltos[t-2].second) <= n)
		{
			operoArriba += saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
			saltos[t-2].second += saltos[t-1].second;
			saltos.erase(saltos.end());
			t--;
		}
		operoArriba += ordenarDP(k,saltos,n);
	}
	else
	{
		operoArriba = saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
		operoArriba -= (saltos[t-1].second+saltos[t-2].second-k);
	}

	if(operoArriba < operoAbajo){return operoArriba;}
	else{return operoAbajo;}

	/*
	if(k==1){return make_pair(0,0);}
	pair<int,int> operaciones = ordenarDP(a,k-1, cantNecesAbajo, cantNecesArriba, saltos);
	if(operaciones.first !=0 && operaciones.second !=0){return make_pair(operaciones.first+1,operaciones.second);}
	if(operaciones.first==0 && operaciones.second !=0)
	{
		if(operaciones.second<cantNecesArriba){respuesta= make_pair(0,operaciones.second+(a[k]-a[k-1])*(k-1));
			bool bandera = true;
			for (int i = k; bandera && i<n; ++i)
			{
				if(a[i]==a[k-1]){respuesta--}
					else{bandera=false;}
			}
			return respuesta; //aca el problema es cuando llegas al numero deseado antes de que TODOS lleguen al proximo nivel
		}
		else{
			int d= saltos[0].first-saltos[1].first,
			a1 = saltos[0].second, a2 = n-a1;
			if(2*saltos[0].second< n){
		} */
}

int main(){
	unsigned n=0, k=0;
	cin >> n >> k;
	vector<unsigned> a(0);
	unsigned numero =0;
	for (unsigned i = 0; i < n; i++)
	{
		cin >> numero;
		a.push_back(numero);
	}
	sort(a.begin(),a.end());

	vector<pair<unsigned,unsigned>> saltos(0);
	int ultimoSalto=-1;
	for (unsigned i = 1; i < n; i++)
	{
		if(a[i]!=a[i-1]){
			if(i-1-ultimoSalto >= k){k=1;};
			saltos.push_back(make_pair(a[i-1]-a[0],i-1-ultimoSalto));
			ultimoSalto=i-1;
		}
	}
	if(n-1-ultimoSalto >= k){k=1;};
	saltos.push_back(make_pair(a[n-1]-a[0],n-1-ultimoSalto));
	if(k==1){cout << 0; return 0;}
	cout << obvio(saltos,k,n);
}

	/*
	if(2*k<=n){cout << trivial;}
	else{
		unsigned operoAbajo=0, operoArriba=0;
		while(2*(saltos[0].second+saltos[1].second) <= n)
		{
			operoAbajo += saltos[0].second*(saltos[1].first-saltos[0].first);
			saltos[1].second += saltos[0].second;
			saltos.erase(saltos.begin());
		}
		unsigned t=saltos.size();
		while(2*(saltos[t-1].second+saltos[t-2].second) <= n)
		{
			operoArriba += saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
			saltos[t-2].second += saltos[t-1].second;
			saltos.erase(saltos.end());
			t--;
		}

		unsigned topeAbajo=0,topeArriba=0,suma1=0,suma2=0;
		for (unsigned i = 0; suma1<k ; i++)
		{
			suma1 += saltos[i].second;
			topeAbajo++;
		}
		for (unsigned i = 0; suma2<k ; i++)
		{
			suma2 += saltos[t-1-i].second;
			topeArriba++;
		}

		tuple<int,int,int,bool> zzz = {0,0,0,false};
		vector<tuple<int,int,int,bool>> xxx(0);
		vector<vector<tuple<int,int,int,bool>>> caja(0);
		int min=topeArriba;
		for (int j = 0; j < min+1; j++)
		{
			xxx.push_back(zzz);
		}
		for (unsigned i = 0; i < topeAbajo+1; i++)
		{
			if(t-1-i < topeArriba){xxx.erase(xxx.begin());}
			caja.push_back(xxx);
		}
		//aca calcular los bordes de la cuadrilla
		unsigned sumaPivote=suma2;
		for (unsigned i = 0; i < topeArriba; i++)
		{
			if(topeAbajo-2+topeArriba-i <= t-1){caja[topeAbajo-1][topeArriba-1-i] = make_tuple(k-suma1,suma1,sumaPivote,true);}
			sumaPivote -= saltos[t-topeArriba+i].second;
		}
		sumaPivote=suma1;
		for (unsigned i = 0; i < topeAbajo; i++)
		{
			if(topeAbajo+topeArriba-2-i <= t-1){caja[topeAbajo-1-i][topeArriba-1] = make_tuple(k-suma2,sumaPivote,suma2,true);}
			sumaPivote -= saltos[topeAbajo-1-i].second;
		}
		//falta calcular los de i+j=t-1
		suma1=saltos[0].second; suma2=n;
		for (unsigned i = 0; i < t-1; i++)
		{
			if(i < topeAbajo && t-1-i < topeArriba){caja[i][t-1-i] = make_tuple(k-n,suma1,suma2,true);}
			suma1 += saltos[i+1].second;
			suma2 -= saltos[i].second;
		}

	//	cout << ordenarDP(k,saltos,n);
	//	cout << ordenarSinDP(a,k);
		unsigned noTrivial = get<0>(operacionesDP(k,saltos,0,0,topeAbajo,topeArriba,caja))+operoAbajo+operoArriba;
		if(noTrivial < trivial){cout << noTrivial;}else{cout << trivial;} //chequear que quedan guardados los casos de arriba
	}
}
*/


#include <iostream>
#include <vector>
#include <algorithm>
#include <tuple>

using namespace std;

int obvio(vector<pair<unsigned,unsigned>> saltos, unsigned k, unsigned n){
	if(k==1){return 0;}
	unsigned t = saltos.size();
	unsigned abajo=0 , arriba=0, medio=0, sumaAbajo = saltos[0].second, sumaArriba = saltos[t-1].second;
	bool bandera =false;

	unsigned i=1;
	while(sumaAbajo<k){
		abajo += sumaAbajo*(saltos[i].first-saltos[i-1].first);
		sumaAbajo += saltos[i].second;
		i++;
	}
	abajo -= (sumaAbajo-k);
	i=1;
	while(sumaArriba<k){
		arriba += sumaArriba*(saltos[t-i].first-saltos[t-i-1].first);
		sumaArriba += saltos[t-1-i].second;
		i++;
	}
	arriba -= (sumaArriba-k);
	if(2*saltos[0].second < n && 2*saltos[t-1].second < n){
		bandera =true;
		unsigned sumaMedAbajo=saltos[0].second, sumaMedArriba=saltos[t-1].second;
		i=1;
		while(2*(sumaMedAbajo)<n && 2*(sumaMedArriba)<n){
			medio += sumaMedAbajo*(saltos[i].first-saltos[i-1].first);
			sumaMedAbajo += saltos[i].second;
			medio += sumaMedArriba*(saltos[t-i].first-saltos[t-i-1].first);
			sumaMedArriba += saltos[t-1-i].second;
			i++;
		}
		unsigned j=i;
		if(2*(sumaMedAbajo)>=n){
			while(i-1 <= t-1-j){
				medio += sumaMedArriba*(saltos[t-j].first-saltos[t-j-1].first);
				sumaMedArriba += saltos[t-1-j].second;
				j++;
			}
		}
		else{
			while(j-1 <= t-1-i){
				medio += sumaMedAbajo*(saltos[j].first-saltos[j-1].first);
				sumaMedAbajo += saltos[j].second;
				j++;
			}
		}
	medio -= (n-k);
	}
	if(bandera){
		if(medio <= abajo && medio <= arriba){return medio;}
		else{if(abajo<=arriba){return abajo;}
			else{return arriba;}}
	}
	if(abajo<=arriba){return abajo;}
	else{return arriba;}
}

tuple<int,int,int> operacionesDP(int k, vector<pair<unsigned,unsigned>> &saltos, int i , int j, int topeAbajo, int topeArriba, vector<vector<tuple<int,int,int,bool>>> &caja){
	if(get<3>(caja[i][j])){return make_tuple(get<0>(caja[i][j]),get<1>(caja[i][j]),get<2>(caja[i][j]));}
	int t = saltos.size();
	if (i==topeAbajo-1 || j==topeArriba-1 || i+j == t-1)
	{
		int sumaAbajo =0;
		for (int abcd = 0; abcd <= i ; abcd++)
		{
			sumaAbajo += saltos[abcd].second;
		}

		int sumaArriba = 0;
		for (int abcd = 0; abcd <= j ; abcd++)
		{
			sumaArriba += saltos[t-1-abcd].second;
		}

		if(i+j==t-1){caja[i][j] = make_tuple(k-sumaArriba-sumaAbajo+saltos[i].second,sumaAbajo/*+sumaArriba-saltos[i].second*/,sumaArriba/*+sumaAbajo-saltos[i].second*/,true);}
		else{if(i==topeAbajo-1){caja[i][j] = make_tuple(k-sumaAbajo,sumaAbajo,sumaArriba,true);}
		else{if(j==topeArriba-1){caja[i][j] = make_tuple(k-sumaArriba,sumaAbajo,sumaArriba,true);}}}
		//cout << i << ' ' << j << endl; // <<" caso inicial " << get<1>(caja[i][j]) << ' ' << get<2>(caja[i][j]) <<' ' << get<0>(caja[i][j]) << endl; //aca
		return make_tuple(get<0>(caja[i][j]),get<1>(caja[i][j]),get<2>(caja[i][j]));
	}
	tuple<int,int,int> operoAbajo = operacionesDP(k,saltos,i+1,j,topeAbajo,topeArriba,caja), operoArriba = operacionesDP(k,saltos,i,j+1,topeAbajo,topeArriba,caja);
	int opNecAbajo = (get<1>(operoAbajo)-saltos[i+1].second)*(saltos[i+1].first-saltos[i].first);
	int opNecArriba = (get<2>(operoArriba)-saltos[t-1-j-1].second)*(saltos[t-1-j].first-saltos[t-1-j-1].first);
	if(opNecAbajo + get<0>(operoAbajo) < opNecArriba + get<0>(operoArriba)){caja[i][j] = make_tuple(opNecAbajo + get<0>(operoAbajo),get<1>(operoAbajo)-saltos[i+1].second,get<2>(operoAbajo),true);}
	else{caja[i][j] = make_tuple(opNecArriba + get<0>(operoArriba),get<1>(operoArriba),get<2>(operoArriba)-saltos[t-1-j-1].second,true);}

	//cout << i << ' ' << j << endl;// <<' ' << get<1>(caja[i][j]) << ' ' << get<2>(caja[i][j]) <<' ' << get<0>(caja[i][j]) << endl; //aca
	return make_tuple(get<0>(caja[i][j]),get<1>(caja[i][j]),get<2>(caja[i][j]));
}

int ordenarSinDP(vector<int> a, int k){
	int n = a.size();
	vector<pair<int,int>> saltos(0);
	int ultimoSalto=-1;
	pair<int,int> bhsajd;
	for (int i = 1; i < n; i++)
	{
		if(a[i]!=a[i-1]){
			if(i-1-ultimoSalto >= k){return 0;};
			bhsajd = make_pair(a[i-1],i-1-ultimoSalto);
			saltos.push_back(bhsajd);
			ultimoSalto=i-1;
		}
	}
	if(n-1-ultimoSalto >= k){return 0;};
	bhsajd = make_pair(a[n-1],n-1-ultimoSalto);
	saltos.push_back(bhsajd);
	int t = saltos.size();
	if(t==1){return 0;}
	if(t==2){
		int d = saltos[1].first-saltos[0].first,
		abcd = saltos[0].second;
		if(2*abcd < n){return (d-1)*abcd+(k-(n-abcd));}
		else{return (d-1)*(n-abcd)+(k-abcd);}
	}
	int sumaAbajo =0, sumaArriba=0;
	int suma=0, suma2=0, topeAbajo=0, topeArriba=0;
	int limiteAbajo = n-saltos[t-1].second, limiteArriba = n-saltos[0].second;
	bool dosOperaciones = true;
	if (k<=limiteAbajo)
	{
		for (int i = 0; suma < k; i++)
		{
			suma += saltos[i].second;
			topeAbajo=i;
			if(i!=0){sumaAbajo +=(saltos[i].first-saltos[i-1].first)*(suma-saltos[i].second);}
		};
		if(topeAbajo!=0){sumaAbajo -= (suma-k);}
	}
	else
		{
			dosOperaciones = false;
			vector<int> I(t,0), S(t,0);
			for (int i = 1; i < t; i++)
			{
				suma += saltos[i-1].second;
				I[i] += suma*(saltos[i].first-saltos[i-1].first);
				I[i] += I[i-1];
			}
			for (int i = t-2; i >= 0 ;

			 i--)
			{
				suma2 += saltos[i+1].second;
				S[i] += suma2*(saltos[i+1].first-saltos[i].first);
				S[i] += S[i+1];
			}
			sumaAbajo = I[0]+S[0];
			for (int i = 0; i < t; i++)
			{
				if(sumaAbajo > I[i]+S[i]){sumaAbajo = I[i]+S[i];}
			}
			sumaAbajo -= (n-k);
		}
	suma=0; suma2=0;
	if(k<=limiteArriba)
	{
		for (int i = t-1; suma < k; i--) //aca reemplace t por n
		{
			suma += saltos[i].second;
			topeArriba=i;
			if(i!=t-1){sumaArriba +=(saltos[i+1].first-saltos[i].first)*(suma-saltos[i].second);} // aca tambien
		}
		if(topeArriba!=t-1){sumaArriba -= (suma-k);} //aca tambien
	}
	else
	{
		if(dosOperaciones){
			vector<int> I(t,0), S(t,0);
			for (int i = 1; i < t; i++)
			{
				suma += saltos[i-1].second;
				I[i] += suma*(saltos[i].first-saltos[i-1].first);
				I[i] += I[i-1];
			}
			for (int i = t-2; i >= 0 ; i--)
			{
				suma2 += saltos[i+1].second;
				S[i] += suma2*(saltos[i+1].first-saltos[i].first);
				S[i] += S[i+1];
			}
			sumaArriba = I[0]+S[0];
			for (int i = 0; i < t; i++)
			{
				if(sumaArriba > I[i]+S[i]){sumaArriba = I[i]+S[i];}
			}
			sumaArriba -= (n-k);
		}else{sumaArriba=sumaAbajo;}
	}
	if(sumaArriba<sumaAbajo){return sumaArriba;}
	else{return sumaAbajo;}

}

unsigned ordenarDP(unsigned &k, vector<pair<unsigned,unsigned>> &saltos, unsigned n){
	unsigned t= saltos.size();
	if(t==1){return 0;}
	/*for (unsigned i = 0; i < t; ++i)
	{
		if(saltos[i].second >= k){return 0;}
	}*/
	vector<pair<unsigned,unsigned>> b=saltos;
	unsigned operoArriba=0, operoAbajo=0;
	if (saltos[0].second+saltos[1].second < k)
	{
		if(2*(b[0].second+b[1].second) > n)
		{
			operoAbajo += b[0].second*(b[1].first-b[0].first);
			b[1].second += b[0].second;
			b.erase(b.begin());
		}
		while(b[0].second+b[1].second < k && 2*(b[0].second+b[1].second) <= n)
		{
			operoAbajo += b[0].second*(b[1].first-b[0].first);
			b[1].second += b[0].second;
			b.erase(b.begin());
		}
		operoAbajo += ordenarDP(k,b,n);
	}
	else
	{
		operoAbajo = saltos[0].second*(saltos[1].first-saltos[0].first);
		operoAbajo -= (saltos[0].second+saltos[1].second-k);
	}

	if (saltos[t-1].second+saltos[t-2].second < k)
	{
		if (2*(saltos[t-1].second+saltos[t-2].second) > n)
		{
			operoArriba += saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
			saltos[t-2].second += saltos[t-1].second;
			saltos.erase(saltos.end());
		}
		while(saltos[t-1].second+saltos[t-2].second < k && 2*(saltos[t-1].second+saltos[t-2].second) <= n)
		{
			operoArriba += saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
			saltos[t-2].second += saltos[t-1].second;
			saltos.erase(saltos.end());
			t--;
		}
		operoArriba += ordenarDP(k,saltos,n);
	}
	else
	{
		operoArriba = saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
		operoArriba -= (saltos[t-1].second+saltos[t-2].second-k);
	}

	if(operoArriba < operoAbajo){return operoArriba;}
	else{return operoAbajo;}

	/*
	if(k==1){return make_pair(0,0);}
	pair<int,int> operaciones = ordenarDP(a,k-1, cantNecesAbajo, cantNecesArriba, saltos);
	if(operaciones.first !=0 && operaciones.second !=0){return make_pair(operaciones.first+1,operaciones.second);}
	if(operaciones.first==0 && operaciones.second !=0)
	{
		if(operaciones.second<cantNecesArriba){respuesta= make_pair(0,operaciones.second+(a[k]-a[k-1])*(k-1));
			bool bandera = true;
			for (int i = k; bandera && i<n; ++i)
			{
				if(a[i]==a[k-1]){respuesta--}
					else{bandera=false;}
			}
			return respuesta; //aca el problema es cuando llegas al numero deseado antes de que TODOS lleguen al proximo nivel
		}
		else{
			int d= saltos[0].first-saltos[1].first,
			a1 = saltos[0].second, a2 = n-a1;
			if(2*saltos[0].second< n){
		} */
}

int main(){
	unsigned n=0, k=0;
	cin >> n >> k;
	vector<unsigned> a(0);
	unsigned numero =0;
	for (unsigned i = 0; i < n; i++)
	{
		cin >> numero;
		a.push_back(numero);
	}
	sort(a.begin(),a.end());

	vector<pair<unsigned,unsigned>> saltos(0);
	int ultimoSalto=-1;
	for (unsigned i = 1; i < n; i++)
	{
		if(a[i]!=a[i-1]){
			if(i-1-ultimoSalto >= k){k=1;};
			saltos.push_back(make_pair(a[i-1]-a[0],i-1-ultimoSalto));
			ultimoSalto=i-1;
		}
	}
	if(n-1-ultimoSalto >= k){k=1;};
	saltos.push_back(make_pair(a[n-1]-a[0],n-1-ultimoSalto));
	if(k==1){cout << 0; return 0;}

	unsigned t = saltos.size();
	unsigned topeAbajo=0,topeArriba=0,suma1=0,suma2=0;
	for (unsigned i = 0; i < t; i++)
	{
		if(suma1<k){
			suma1 += saltos[i].second;
			topeAbajo++;
		}
		if(suma2<k){
			suma2 += saltos[t-1-i].second;
			topeArriba++;
		}
	}

/*

	vector<pair<unsigned,unsigned>> b=saltos;
	unsigned operoArriba=0, operoAbajo=0, contadorAbajo=0, contadorArriba=0;
	if (saltos[0].second+saltos[1].second < k)
	{
		if(2*(b[0].second+b[1].second) > n)
		{
			operoAbajo += b[0].second*(b[1].first-b[0].first);
			b[1].second += b[0].second;
			b.erase(b.begin());
			contadorAbajo++;
		}
		while(b[0].second+b[1].second < k && 2*(b[0].second+b[1].second) <= n)
		{
			operoAbajo += b[0].second*(b[1].first-b[0].first);
			b[1].second += b[0].second;
			b.erase(b.begin());
			contadorAbajo++;
		}
		operoAbajo += operacionesDP(); //no se que le tengo que meter aca
	}
	else
	{
		operoAbajo = saltos[0].second*(saltos[1].first-saltos[0].first);
		operoAbajo -= (saltos[0].second+saltos[1].second-k);
	}

	if (saltos[t-1].second+saltos[t-2].second < k)
	{
		if (2*(saltos[t-1].second+saltos[t-2].second) > n)
		{
			operoArriba += saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
			saltos[t-2].second += saltos[t-1].second;
			saltos.erase(saltos.end());
			contadorArriba++;
		}
		while(saltos[t-1].second+saltos[t-2].second < k && 2*(saltos[t-1].second+saltos[t-2].second) <= n)
		{
			operoArriba += saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
			saltos[t-2].second += saltos[t-1].second;
			saltos.erase(saltos.end());
			t--;
			contadorArriba++;
		}
		operoArriba += operacionesDP(); //no se que le tengo que poner aca
	}
	else
	{
		operoArriba = saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
		operoArriba -= (saltos[t-1].second+saltos[t-2].second-k);
	}
*/

// aca hay una separacion

/*
	tuple<int,int,int,bool> zzz = {0,0,0,false};
	vector<tuple<int,int,int,bool>> xxx(0);
	vector<vector<tuple<int,int,int,bool>>> caja(0);
	int min=topeArriba;
	for (int j = 0; j < min+1; j++)
	{
		xxx.push_back(zzz);
	}
	for (unsigned i = 0; i < topeAbajo+1; i++)
	{
		if(t-1-i < topeArriba){xxx.erase(xxx.begin());}
		caja.push_back(xxx);
	} */

	cout << obvio(saltos,k,n);

//	cout << ordenarDP(k,saltos,n);
//	cout << ordenarSinDP(a,k);
//	cout << get<0>(operacionesDP(k,saltos,0,0,topeAbajo,topeArriba,caja));
	// si se vuelve a ir en tiempo, puedo hacer que operar una vez sea operar muchas veces hasta alcanzar el tope o la mitad de elementos
}


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

using namespace std;

int ordenarSinDP(vector<int> a, int k){
	int n = a.size();
	vector<pair<int,int>> saltos(0);
	int ultimoSalto=-1;
	pair<int,int> bhsajd;
	for (int i = 1; i < n; i++)
	{
		if(a[i]!=a[i-1]){
			if(i-1-ultimoSalto >= k){return 0;};
			bhsajd = make_pair(a[i-1],i-1-ultimoSalto);
			saltos.push_back(bhsajd);
			ultimoSalto=i-1;
		}
	}
	if(n-1-ultimoSalto >= k){return 0;};
	bhsajd = make_pair(a[n-1],n-1-ultimoSalto);
	saltos.push_back(bhsajd);
	int t = saltos.size();
	if(t==1){return 0;}
	if(t==2){
		int d = saltos[1].first-saltos[0].first,
		abcd = saltos[0].second;
		if(2*abcd < n){return (d-1)*abcd+(k-(n-abcd));}
		else{return (d-1)*(n-abcd)+(k-abcd);}
	}
	int sumaAbajo =0, sumaArriba=0;
	int suma=0, suma2=0, topeAbajo=0, topeArriba=0;
	int limiteAbajo = n-saltos[t-1].second, limiteArriba = n-saltos[0].second;
	bool dosOperaciones = true;
	if (k<=limiteAbajo)
	{
		for (int i = 0; suma < k; i++)
		{
			suma += saltos[i].second;
			topeAbajo=i;
			if(i!=0){sumaAbajo +=(saltos[i].first-saltos[i-1].first)*(suma-saltos[i].second);}
		};
		if(topeAbajo!=0){sumaAbajo -= (suma-k);}
	}
	else
		{
			dosOperaciones = false;
			vector<int> I(t,0), S(t,0);
			for (int i = 1; i < t; i++)
			{
				suma += saltos[i-1].second;
				I[i] += suma*(saltos[i].first-saltos[i-1].first);
				I[i] += I[i-1];
			}
			for (int i = t-2; i >= 0 ;

			 i--)
			{
				suma2 += saltos[i+1].second;
				S[i] += suma2*(saltos[i+1].first-saltos[i].first);
				S[i] += S[i+1];
			}
			sumaAbajo = I[0]+S[0];
			for (int i = 0; i < t; i++)
			{
				if(sumaAbajo > I[i]+S[i]){sumaAbajo = I[i]+S[i];}
			}
			sumaAbajo -= (n-k);
		}
	suma=0; suma2=0;
	if(k<=limiteArriba)
	{
		for (int i = t-1; suma < k; i--) //aca reemplace t por n
		{
			suma += saltos[i].second;
			topeArriba=i;
			if(i!=t-1){sumaArriba +=(saltos[i+1].first-saltos[i].first)*(suma-saltos[i].second);} // aca tambien
		}
		if(topeArriba!=t-1){sumaArriba -= (suma-k);} //aca tambien
	}
	else
	{
		if(dosOperaciones){
			vector<int> I(t,0), S(t,0);
			for (int i = 1; i < t; i++)
			{
				suma += saltos[i-1].second;
				I[i] += suma*(saltos[i].first-saltos[i-1].first);
				I[i] += I[i-1];
			}
			for (int i = t-2; i >= 0 ; i--)
			{
				suma2 += saltos[i+1].second;
				S[i] += suma2*(saltos[i+1].first-saltos[i].first);
				S[i] += S[i+1];
			}
			sumaArriba = I[0]+S[0];
			for (int i = 0; i < t; i++)
			{
				if(sumaArriba > I[i]+S[i]){sumaArriba = I[i]+S[i];}
			}
			sumaArriba -= (n-k);
		}else{sumaArriba=sumaAbajo;}
	}
	if(sumaArriba<sumaAbajo){return sumaArriba;}
	else{return sumaAbajo;}

}

int ordenarDP(int &k, vector<pair<int,int>> &saltos){
	int t= saltos.size();
	if(t==1){return 0;}
	for (int i = 0; i < t; ++i)
	{
		if(saltos[i].second >= k){return 0;}
	}
	vector<pair<int,int>> b=saltos;
	int operoArriba=0, operoAbajo=0;
	if (saltos[0].second+saltos[1].second < k)
	{
		operoAbajo = saltos[0].second*(saltos[1].first-saltos[0].first);
		b[1].second += b[0].second;
		b.erase(b.begin());
		operoAbajo += ordenarDP(k,b);
	}
	else
	{
		operoAbajo = saltos[0].second*(saltos[1].first-saltos[0].first);
		operoAbajo -= (saltos[0].second+saltos[1].second-k);
	}

	if (saltos[t-1].second+saltos[t-2].second < k)
	{
		operoArriba = saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
		saltos[t-2].second += saltos[t-1].second;
		saltos.erase(saltos.end());
		operoArriba += ordenarDP(k,saltos);
	}
	else
	{
		operoArriba = saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
		operoArriba -= (saltos[t-1].second+saltos[t-2].second-k);
	}

	if(operoArriba < operoAbajo){return operoArriba;}
	else{return operoAbajo;}

	/*
	if(k==1){return make_pair(0,0);}
	pair<int,int> operaciones = ordenarDP(a,k-1, cantNecesAbajo, cantNecesArriba, saltos);
	if(operaciones.first !=0 && operaciones.second !=0){return make_pair(operaciones.first+1,operaciones.second);}
	if(operaciones.first==0 && operaciones.second !=0)
	{
		if(operaciones.second<cantNecesArriba){respuesta= make_pair(0,operaciones.second+(a[k]-a[k-1])*(k-1));
			bool bandera = true;
			for (int i = k; bandera && i<n; ++i)
			{
				if(a[i]==a[k-1]){respuesta--}
					else{bandera=false;}
			}
			return respuesta; //aca el problema es cuando llegas al numero deseado antes de que TODOS lleguen al proximo nivel
		}
		else{
			int d= saltos[0].first-saltos[1].first,
			a1 = saltos[0].second, a2 = n-a1;
			if(2*saltos[0].second< n){
		} */
}

int main(){
	int n=0, k=0;
	cin >> n >> k;
	vector<int> a(0);
	int numero =0;
	for (int i = 0; i < n; i++)
	{
		cin >> numero;
		a.push_back(numero);
	}
	sort(a.begin(),a.end());

	vector<pair<int,int>> saltos(0);
	int ultimoSalto=-1;
	pair<int,int> bhsajd;
	for (int i = 1; i < n; i++)
	{
		if(a[i]!=a[i-1]){
			if(i-1-ultimoSalto >= k){return 0;};
			bhsajd = make_pair(a[i-1],i-1-ultimoSalto);
			saltos.push_back(bhsajd);
			ultimoSalto=i-1;
		}
	}
	if(n-1-ultimoSalto >= k){return 0;};
	bhsajd = make_pair(a[n-1],n-1-ultimoSalto);
	saltos.push_back(bhsajd);

	cout << ordenarDP(k,saltos);
//	cout << ordenarSinDP(a,k);
}


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

using namespace std;

int ordenarSinDP(vector<int> a, int k){
	int n = a.size();
	vector<pair<int,int>> saltos(0);
	int ultimoSalto=-1;
	pair<int,int> bhsajd;
	for (int i = 1; i < n; i++)
	{
		if(a[i]!=a[i-1]){
			if(i-1-ultimoSalto >= k){return 0;};
			bhsajd = make_pair(a[i-1],i-1-ultimoSalto);
			saltos.push_back(bhsajd);
			ultimoSalto=i-1;
		}
	}
	if(n-1-ultimoSalto >= k){return 0;};
	bhsajd = make_pair(a[n-1],n-1-ultimoSalto);
	saltos.push_back(bhsajd);
	int t = saltos.size();
	if(t==1){return 0;}
	if(t==2){
		int d = saltos[1].first-saltos[0].first,
		abcd = saltos[0].second;
		if(2*abcd < n){return (d-1)*abcd+(k-(n-abcd));}
		else{return (d-1)*(n-abcd)+(k-abcd);}
	}
	int sumaAbajo =0, sumaArriba=0;
	int suma=0, suma2=0, topeAbajo=0, topeArriba=0;
	int limiteAbajo = n-saltos[t-1].second, limiteArriba = n-saltos[0].second;
	bool dosOperaciones = true;
	if (k<=limiteAbajo)
	{
		for (int i = 0; suma < k; i++)
		{
			suma += saltos[i].second;
			topeAbajo=i;
			if(i!=0){sumaAbajo +=(saltos[i].first-saltos[i-1].first)*(suma-saltos[i].second);}
		};
		if(topeAbajo!=0){sumaAbajo -= (suma-k);}
	}
	else
		{
			dosOperaciones = false;
			vector<int> I(t,0), S(t,0);
			for (int i = 1; i < t; i++)
			{
				suma += saltos[i-1].second;
				I[i] += suma*(saltos[i].first-saltos[i-1].first);
				I[i] += I[i-1];
			}
			for (int i = t-2; i >= 0 ;

			 i--)
			{
				suma2 += saltos[i+1].second;
				S[i] += suma2*(saltos[i+1].first-saltos[i].first);
				S[i] += S[i+1];
			}
			sumaAbajo = I[0]+S[0];
			for (int i = 0; i < t; i++)
			{
				if(sumaAbajo > I[i]+S[i]){sumaAbajo = I[i]+S[i];}
			}
			sumaAbajo -= (n-k);
		}
	suma=0; suma2=0;
	if(k<=limiteArriba)
	{
		for (int i = t-1; suma < k; i--) //aca reemplace t por n
		{
			suma += saltos[i].second;
			topeArriba=i;
			if(i!=t-1){sumaArriba +=(saltos[i+1].first-saltos[i].first)*(suma-saltos[i].second);} // aca tambien
		}
		if(topeArriba!=t-1){sumaArriba -= (suma-k);} //aca tambien
	}
	else
	{
		if(dosOperaciones){
			vector<int> I(t,0), S(t,0);
			for (int i = 1; i < t; i++)
			{
				suma += saltos[i-1].second;
				I[i] += suma*(saltos[i].first-saltos[i-1].first);
				I[i] += I[i-1];
			}
			for (int i = t-2; i >= 0 ; i--)
			{
				suma2 += saltos[i+1].second;
				S[i] += suma2*(saltos[i+1].first-saltos[i].first);
				S[i] += S[i+1];
			}
			sumaArriba = I[0]+S[0];
			for (int i = 0; i < t; i++)
			{
				if(sumaArriba > I[i]+S[i]){sumaArriba = I[i]+S[i];}
			}
			sumaArriba -= (n-k);
		}else{sumaArriba=sumaAbajo;}
	}
	if(sumaArriba<sumaAbajo){return sumaArriba;}
	else{return sumaAbajo;}

}

int ordenarDP(int &k, vector<pair<int,int>> &saltos){
	int t= saltos.size();
	if(t==1){return 0;}
	for (int i = 0; i < t; ++i)
	{
		if(saltos[i].second >= k){return 0;}
	}
	vector<pair<int,int>> b=saltos;
	int operoArriba=0, operoAbajo=0;
	if (saltos[0].second+saltos[1].second < k)
	{
		operoAbajo = saltos[0].second*(saltos[1].first-saltos[0].first);
		b[1].second += b[0].second;
		b.erase(b.begin());
		operoAbajo += ordenarDP(k,b);
	}
	else
	{
		operoAbajo = saltos[0].second*(saltos[1].first-saltos[0].first);
		operoAbajo -= (saltos[0].second+saltos[1].second-k);
	}

	if (saltos[t-1].second+saltos[t-2].second < k)
	{
		operoArriba = saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
		saltos[t-2].second += saltos[t-1].second;
		saltos.erase(saltos.end());
		operoArriba += ordenarDP(k,saltos);
	}
	else
	{
		operoArriba = saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
		operoArriba -= (saltos[t-1].second+saltos[t-2].second-k);
	}

	if(operoArriba < operoAbajo){return operoArriba;}
	else{return operoAbajo;}

	/*
	if(k==1){return make_pair(0,0);}
	pair<int,int> operaciones = ordenarDP(a,k-1, cantNecesAbajo, cantNecesArriba, saltos);
	if(operaciones.first !=0 && operaciones.second !=0){return make_pair(operaciones.first+1,operaciones.second);}
	if(operaciones.first==0 && operaciones.second !=0)
	{
		if(operaciones.second<cantNecesArriba){respuesta= make_pair(0,operaciones.second+(a[k]-a[k-1])*(k-1));
			bool bandera = true;
			for (int i = k; bandera && i<n; ++i)
			{
				if(a[i]==a[k-1]){respuesta--}
					else{bandera=false;}
			}
			return respuesta; //aca el problema es cuando llegas al numero deseado antes de que TODOS lleguen al proximo nivel
		}
		else{
			int d= saltos[0].first-saltos[1].first,
			a1 = saltos[0].second, a2 = n-a1;
			if(2*saltos[0].second< n){
		} */
}

int main(){
	int n=0, k=0;
	cin >> n >> k;
	vector<int> a(0);
	int numero =0;
	for (int i = 0; i < n; i++)
	{
		cin >> numero;
		a.push_back(numero);
	}
	sort(a.begin(),a.end());

	vector<pair<int,int>> saltos(0);
	int ultimoSalto=-1;
	pair<int,int> bhsajd;
	for (int i = 1; i < n; i++)
	{
		if(a[i]!=a[i-1]){
			if(i-1-ultimoSalto >= k){return 0;};
			bhsajd = make_pair(a[i-1],i-1-ultimoSalto);
			saltos.push_back(bhsajd);
			ultimoSalto=i-1;
		}
	}
	if(n-1-ultimoSalto >= k){return 0;};
	bhsajd = make_pair(a[n-1],n-1-ultimoSalto);
	saltos.push_back(bhsajd);

	cout << ordenarDP(k,saltos);
///	cout << ordenarSinDP(a,k);
}


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

using namespace std;

int ordenarSinDP(vector<int> a, int k){
	int n = a.size();
	vector<pair<int,int>> saltos(0);
	int ultimoSalto=-1;
	pair<int,int> bhsajd;
	for (int i = 1; i < n; i++)
	{
		if(a[i]!=a[i-1]){
			if(i-1-ultimoSalto >= k){return 0;};
			bhsajd = make_pair(a[i-1],i-1-ultimoSalto);
			saltos.push_back(bhsajd);
			ultimoSalto=i-1;
		}
	}
	if(n-1-ultimoSalto >= k){return 0;};
	bhsajd = make_pair(a[n-1],n-1-ultimoSalto);
	saltos.push_back(bhsajd);
	int t = saltos.size();
	if(t==1){return 0;}
	if(t==2){
		int d = saltos[1].first-saltos[0].first,
		abcd = saltos[0].second;
		if(2*abcd < n){return (d-1)*abcd+(k-(n-abcd));}
		else{return (d-1)*(n-abcd)+(k-abcd);}
	}
	int sumaAbajo =0, sumaArriba=0;
	int suma=0, suma2=0, topeAbajo=0, topeArriba=0;
	int limiteAbajo = n-saltos[t-1].second, limiteArriba = n-saltos[0].second;
	bool dosOperaciones = true;
	if (k<=limiteAbajo)
	{
		for (int i = 0; suma < k; i++)
		{
			suma += saltos[i].second;
			topeAbajo=i;
			if(i!=0){sumaAbajo +=(saltos[i].first-saltos[i-1].first)*(suma-saltos[i].second);}
		};
		if(topeAbajo!=0){sumaAbajo -= (suma-k);}
	}
	else
		{
			dosOperaciones = false;
			vector<int> I(t,0), S(t,0);
			for (int i = 1; i < t; i++)
			{
				suma += saltos[i-1].second;
				I[i] += suma*(saltos[i].first-saltos[i-1].first);
				I[i] += I[i-1];
			}
			for (int i = t-2; i >= 0 ;

			 i--)
			{
				suma2 += saltos[i+1].second;
				S[i] += suma2*(saltos[i+1].first-saltos[i].first);
				S[i] += S[i+1];
			}
			sumaAbajo = I[0]+S[0];
			for (int i = 0; i < t; i++)
			{
				if(sumaAbajo > I[i]+S[i]){sumaAbajo = I[i]+S[i];}
			}
			sumaAbajo -= (n-k);
		}
	suma=0; suma2=0;
	if(k<=limiteArriba)
	{
		for (int i = t-1; suma < k; i--) //aca reemplace t por n
		{
			suma += saltos[i].second;
			topeArriba=i;
			if(i!=t-1){sumaArriba +=(saltos[i+1].first-saltos[i].first)*(suma-saltos[i].second);} // aca tambien
		}
		if(topeArriba!=t-1){sumaArriba -= (suma-k);} //aca tambien
	}
	else
	{
		if(dosOperaciones){
			vector<int> I(t,0), S(t,0);
			for (int i = 1; i < t; i++)
			{
				suma += saltos[i-1].second;
				I[i] += suma*(saltos[i].first-saltos[i-1].first);
				I[i] += I[i-1];
			}
			for (int i = t-2; i >= 0 ; i--)
			{
				suma2 += saltos[i+1].second;
				S[i] += suma2*(saltos[i+1].first-saltos[i].first);
				S[i] += S[i+1];
			}
			sumaArriba = I[0]+S[0];
			for (int i = 0; i < t; i++)
			{
				if(sumaArriba > I[i]+S[i]){sumaArriba = I[i]+S[i];}
			}
			sumaArriba -= (n-k);
		}else{sumaArriba=sumaAbajo;}
	}
	if(sumaArriba<sumaAbajo){return sumaArriba;}
	else{return sumaAbajo;}

}

unsigned ordenarDP(unsigned &k, vector<pair<unsigned,unsigned>> &saltos){
	unsigned t= saltos.size();
	if(t==1){return 0;}
	for (unsigned i = 0; i < t; ++i)
	{
		if(saltos[i].second >= k){return 0;}
	}
	vector<pair<unsigned,unsigned>> b=saltos;
	unsigned operoArriba=0, operoAbajo=0;
	if (saltos[0].second+saltos[1].second < k)
	{
		operoAbajo = saltos[0].second*(saltos[1].first-saltos[0].first);
		b[1].second += b[0].second;
		b.erase(b.begin());
		operoAbajo += ordenarDP(k,b);
	}
	else
	{
		operoAbajo = saltos[0].second*(saltos[1].first-saltos[0].first);
		operoAbajo -= (saltos[0].second+saltos[1].second-k);
	}

	if (saltos[t-1].second+saltos[t-2].second < k)
	{
		operoArriba = saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
		saltos[t-2].second += saltos[t-1].second;
		saltos.erase(saltos.end());
		operoArriba += ordenarDP(k,saltos);
	}
	else
	{
		operoArriba = saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
		operoArriba -= (saltos[t-1].second+saltos[t-2].second-k);
	}

	if(operoArriba < operoAbajo){return operoArriba;}
	else{return operoAbajo;}

	/*
	if(k==1){return make_pair(0,0);}
	pair<int,int> operaciones = ordenarDP(a,k-1, cantNecesAbajo, cantNecesArriba, saltos);
	if(operaciones.first !=0 && operaciones.second !=0){return make_pair(operaciones.first+1,operaciones.second);}
	if(operaciones.first==0 && operaciones.second !=0)
	{
		if(operaciones.second<cantNecesArriba){respuesta= make_pair(0,operaciones.second+(a[k]-a[k-1])*(k-1));
			bool bandera = true;
			for (int i = k; bandera && i<n; ++i)
			{
				if(a[i]==a[k-1]){respuesta--}
					else{bandera=false;}
			}
			return respuesta; //aca el problema es cuando llegas al numero deseado antes de que TODOS lleguen al proximo nivel
		}
		else{
			int d= saltos[0].first-saltos[1].first,
			a1 = saltos[0].second, a2 = n-a1;
			if(2*saltos[0].second< n){
		} */
}

int main(){
	unsigned n=0, k=0;
	cin >> n >> k;
	vector<unsigned> a(0);
	unsigned numero =0;
	for (unsigned i = 0; i < n; i++)
	{
		cin >> numero;
		a.push_back(numero);
	}
	sort(a.begin(),a.end());

	vector<pair<unsigned,unsigned>> saltos(0);
	int ultimoSalto=-1;
	pair<unsigned,unsigned> bhsajd;
	for (unsigned i = 1; i < n; i++)
	{
		if(a[i]!=a[i-1]){
			if(i-1-ultimoSalto >= k){return 0;};
			bhsajd = make_pair(a[i-1],i-1-ultimoSalto);
			saltos.push_back(bhsajd);
			ultimoSalto=i-1;
		}
	}
	if(n-1-ultimoSalto >= k){return 0;};
	bhsajd = make_pair(a[n-1],n-1-ultimoSalto);
	saltos.push_back(bhsajd);

	cout << ordenarDP(k,saltos);
///	cout << ordenarSinDP(a,k);
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <tuple>

using namespace std;

tuple<int,int,int> operacionesDP(int k, vector<pair<unsigned,unsigned>> saltos, int i , int j, int topeAbajo, int topeArriba, vector<vector<tuple<int,int,int,bool>>> &caja){
	if(get<3>(caja[i][j])){return make_tuple(get<0>(caja[i][j]),get<1>(caja[i][j]),get<2>(caja[i][j]));}
	int t = saltos.size();
	if (i==topeAbajo-1 || j==topeArriba-1 || i+j == t-1)
	{
		int sumaAbajo =0;
		for (int abcd = 0; abcd <= i ; abcd++)
		{
			sumaAbajo += saltos[abcd].second;
		}

		int sumaArriba = 0;
		for (int abcd = 0; abcd <= j ; abcd++)
		{
			sumaArriba += saltos[t-1-abcd].second;
		}

		if(i+j==t-1){caja[i][j] = make_tuple(k-sumaArriba-sumaAbajo+saltos[i].second,sumaAbajo/*+sumaArriba-saltos[i].second*/,sumaArriba/*+sumaAbajo-saltos[i].second*/,true);}
		else{if(i==topeAbajo-1){caja[i][j] = make_tuple(k-sumaAbajo,sumaAbajo,sumaArriba,true);}
		else{if(j==topeArriba-1){caja[i][j] = make_tuple(k-sumaArriba,sumaAbajo,sumaArriba,true);}}}
		//cout << i << ' ' << j <<" caso inicial " << get<1>(caja[i][j]) << ' ' << get<2>(caja[i][j]) <<' ' << get<0>(caja[i][j]) << endl; //aca
		return make_tuple(get<0>(caja[i][j]),get<1>(caja[i][j]),get<2>(caja[i][j]));
	}
	tuple<int,int,int> operoAbajo = operacionesDP(k,saltos,i+1,j,topeAbajo,topeArriba,caja), operoArriba = operacionesDP(k,saltos,i,j+1,topeAbajo,topeArriba,caja);
	int opNecAbajo = (get<1>(operoAbajo)-saltos[i+1].second)*(saltos[i+1].first-saltos[i].first);
	int opNecArriba = (get<2>(operoArriba)-saltos[t-1-j-1].second)*(saltos[t-1-j].first-saltos[t-1-j-1].first);
	if(opNecAbajo + get<0>(operoAbajo) < opNecArriba + get<0>(operoArriba)){caja[i][j] = make_tuple(opNecAbajo + get<0>(operoAbajo),get<1>(operoAbajo)-saltos[i+1].second,get<2>(operoAbajo),true);}
	else{caja[i][j] = make_tuple(opNecArriba + get<0>(operoArriba),get<1>(operoArriba),get<2>(operoArriba)-saltos[t-1-j-1].second,true);}

	//cout << i << ' ' << j <<' ' << get<1>(caja[i][j]) << ' ' << get<2>(caja[i][j]) <<' ' << get<0>(caja[i][j]) << endl; //aca
	return make_tuple(get<0>(caja[i][j]),get<1>(caja[i][j]),get<2>(caja[i][j]));
}

int ordenarSinDP(vector<int> a, int k){
	int n = a.size();
	vector<pair<int,int>> saltos(0);
	int ultimoSalto=-1;
	pair<int,int> bhsajd;
	for (int i = 1; i < n; i++)
	{
		if(a[i]!=a[i-1]){
			if(i-1-ultimoSalto >= k){return 0;};
			bhsajd = make_pair(a[i-1],i-1-ultimoSalto);
			saltos.push_back(bhsajd);
			ultimoSalto=i-1;
		}
	}
	if(n-1-ultimoSalto >= k){return 0;};
	bhsajd = make_pair(a[n-1],n-1-ultimoSalto);
	saltos.push_back(bhsajd);
	int t = saltos.size();
	if(t==1){return 0;}
	if(t==2){
		int d = saltos[1].first-saltos[0].first,
		abcd = saltos[0].second;
		if(2*abcd < n){return (d-1)*abcd+(k-(n-abcd));}
		else{return (d-1)*(n-abcd)+(k-abcd);}
	}
	int sumaAbajo =0, sumaArriba=0;
	int suma=0, suma2=0, topeAbajo=0, topeArriba=0;
	int limiteAbajo = n-saltos[t-1].second, limiteArriba = n-saltos[0].second;
	bool dosOperaciones = true;
	if (k<=limiteAbajo)
	{
		for (int i = 0; suma < k; i++)
		{
			suma += saltos[i].second;
			topeAbajo=i;
			if(i!=0){sumaAbajo +=(saltos[i].first-saltos[i-1].first)*(suma-saltos[i].second);}
		};
		if(topeAbajo!=0){sumaAbajo -= (suma-k);}
	}
	else
		{
			dosOperaciones = false;
			vector<int> I(t,0), S(t,0);
			for (int i = 1; i < t; i++)
			{
				suma += saltos[i-1].second;
				I[i] += suma*(saltos[i].first-saltos[i-1].first);
				I[i] += I[i-1];
			}
			for (int i = t-2; i >= 0 ;

			 i--)
			{
				suma2 += saltos[i+1].second;
				S[i] += suma2*(saltos[i+1].first-saltos[i].first);
				S[i] += S[i+1];
			}
			sumaAbajo = I[0]+S[0];
			for (int i = 0; i < t; i++)
			{
				if(sumaAbajo > I[i]+S[i]){sumaAbajo = I[i]+S[i];}
			}
			sumaAbajo -= (n-k);
		}
	suma=0; suma2=0;
	if(k<=limiteArriba)
	{
		for (int i = t-1; suma < k; i--) //aca reemplace t por n
		{
			suma += saltos[i].second;
			topeArriba=i;
			if(i!=t-1){sumaArriba +=(saltos[i+1].first-saltos[i].first)*(suma-saltos[i].second);} // aca tambien
		}
		if(topeArriba!=t-1){sumaArriba -= (suma-k);} //aca tambien
	}
	else
	{
		if(dosOperaciones){
			vector<int> I(t,0), S(t,0);
			for (int i = 1; i < t; i++)
			{
				suma += saltos[i-1].second;
				I[i] += suma*(saltos[i].first-saltos[i-1].first);
				I[i] += I[i-1];
			}
			for (int i = t-2; i >= 0 ; i--)
			{
				suma2 += saltos[i+1].second;
				S[i] += suma2*(saltos[i+1].first-saltos[i].first);
				S[i] += S[i+1];
			}
			sumaArriba = I[0]+S[0];
			for (int i = 0; i < t; i++)
			{
				if(sumaArriba > I[i]+S[i]){sumaArriba = I[i]+S[i];}
			}
			sumaArriba -= (n-k);
		}else{sumaArriba=sumaAbajo;}
	}
	if(sumaArriba<sumaAbajo){return sumaArriba;}
	else{return sumaAbajo;}

}

unsigned ordenarDP(unsigned &k, vector<pair<unsigned,unsigned>> &saltos, unsigned n){
	unsigned t= saltos.size();
	if(t==1){return 0;}
	/*for (unsigned i = 0; i < t; ++i)
	{
		if(saltos[i].second >= k){return 0;}
	}*/
	vector<pair<unsigned,unsigned>> b=saltos;
	unsigned operoArriba=0, operoAbajo=0;
	if (saltos[0].second+saltos[1].second < k)
	{
		if(2*(b[0].second+b[1].second) > n)
		{
			operoAbajo += b[0].second*(b[1].first-b[0].first);
			b[1].second += b[0].second;
			b.erase(b.begin());
		}
		while(b[0].second+b[1].second < k && 2*(b[0].second+b[1].second) <= n)
		{
			operoAbajo += b[0].second*(b[1].first-b[0].first);
			b[1].second += b[0].second;
			b.erase(b.begin());
		}
		operoAbajo += ordenarDP(k,b,n);
	}
	else
	{
		operoAbajo = saltos[0].second*(saltos[1].first-saltos[0].first);
		operoAbajo -= (saltos[0].second+saltos[1].second-k);
	}

	if (saltos[t-1].second+saltos[t-2].second < k)
	{
		if (2*(saltos[t-1].second+saltos[t-2].second) > n)
		{
			operoArriba += saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
			saltos[t-2].second += saltos[t-1].second;
			saltos.erase(saltos.end());
		}
		while(saltos[t-1].second+saltos[t-2].second < k && 2*(saltos[t-1].second+saltos[t-2].second) <= n)
		{
			operoArriba += saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
			saltos[t-2].second += saltos[t-1].second;
			saltos.erase(saltos.end());
			t--;
		}
		operoArriba += ordenarDP(k,saltos,n);
	}
	else
	{
		operoArriba = saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
		operoArriba -= (saltos[t-1].second+saltos[t-2].second-k);
	}

	if(operoArriba < operoAbajo){return operoArriba;}
	else{return operoAbajo;}

	/*
	if(k==1){return make_pair(0,0);}
	pair<int,int> operaciones = ordenarDP(a,k-1, cantNecesAbajo, cantNecesArriba, saltos);
	if(operaciones.first !=0 && operaciones.second !=0){return make_pair(operaciones.first+1,operaciones.second);}
	if(operaciones.first==0 && operaciones.second !=0)
	{
		if(operaciones.second<cantNecesArriba){respuesta= make_pair(0,operaciones.second+(a[k]-a[k-1])*(k-1));
			bool bandera = true;
			for (int i = k; bandera && i<n; ++i)
			{
				if(a[i]==a[k-1]){respuesta--}
					else{bandera=false;}
			}
			return respuesta; //aca el problema es cuando llegas al numero deseado antes de que TODOS lleguen al proximo nivel
		}
		else{
			int d= saltos[0].first-saltos[1].first,
			a1 = saltos[0].second, a2 = n-a1;
			if(2*saltos[0].second< n){
		} */
}

int main(){
	unsigned n=0, k=0;
	cin >> n >> k;
	vector<unsigned> a(0);
	unsigned numero =0;
	for (unsigned i = 0; i < n; i++)
	{
		cin >> numero;
		a.push_back(numero);
	}
	sort(a.begin(),a.end());

	vector<pair<unsigned,unsigned>> saltos(0);
	int ultimoSalto=-1;
	for (unsigned i = 1; i < n; i++)
	{
		if(a[i]!=a[i-1]){
			if(i-1-ultimoSalto >= k){k=1;};
			saltos.push_back(make_pair(a[i-1]-a[0],i-1-ultimoSalto));
			ultimoSalto=i-1;
		}
	}
	if(n-1-ultimoSalto >= k){k=1;};
	saltos.push_back(make_pair(a[n-1]-a[0],n-1-ultimoSalto));
	if(k==1){cout << 0; return 0;}

	//calcular topeAbajo, topeArriba y caja
	unsigned t = saltos.size();
	unsigned topeAbajo=0,topeArriba=0,suma1=0,suma2=0;
	for (unsigned i = 0; i < t; i++)
	{
		if(suma1<k){
			suma1 += saltos[i].second;
			topeAbajo++;
		}
		if(suma2<k){
			suma2 += saltos[t-1-i].second;
			topeArriba++;
		}
	}
	tuple<int,int,int,bool> zzz = {0,0,0,false};
	vector<tuple<int,int,int,bool>> xxx(topeArriba,zzz);
	vector<vector<tuple<int,int,int,bool>>> caja(topeAbajo,xxx);

///	cout << ordenarDP(k,saltos,n);
///	cout << ordenarSinDP(a,k);
	cout << get<0>(operacionesDP(k,saltos,0,0,topeAbajo,topeArriba,caja));
	// si se vuelve a ir en tiempo, puedo hacer que operar una vez sea operar muchas veces hasta alcanzar el tope o la mitad de elementos
}


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

using namespace std;

int ordenarSinDP(vector<int> a, int k){
	int n = a.size();
	vector<pair<int,int>> saltos(0);
	int ultimoSalto=-1;
	pair<int,int> bhsajd;
	for (int i = 1; i < n; i++)
	{
		if(a[i]!=a[i-1]){
			if(i-1-ultimoSalto >= k){return 0;};
			bhsajd = make_pair(a[i-1],i-1-ultimoSalto);
			saltos.push_back(bhsajd);
			ultimoSalto=i-1;
		}
	}
	if(n-1-ultimoSalto >= k){return 0;};
	bhsajd = make_pair(a[n-1],n-1-ultimoSalto);
	saltos.push_back(bhsajd);
	int t = saltos.size();
	if(t==1){return 0;}
	if(t==2){
		int d = saltos[1].first-saltos[0].first,
		abcd = saltos[0].second;
		if(2*abcd < n){return (d-1)*abcd+(k-(n-abcd));}
		else{return (d-1)*(n-abcd)+(k-abcd);}
	}
	int sumaAbajo =0, sumaArriba=0;
	int suma=0, suma2=0, topeAbajo=0, topeArriba=0;
	int limiteAbajo = n-saltos[t-1].second, limiteArriba = n-saltos[0].second;
	bool dosOperaciones = true;
	if (k<=limiteAbajo)
	{
		for (int i = 0; suma < k; i++)
		{
			suma += saltos[i].second;
			topeAbajo=i;
			if(i!=0){sumaAbajo +=(saltos[i].first-saltos[i-1].first)*(suma-saltos[i].second);}
		};
		if(topeAbajo!=0){sumaAbajo -= (suma-k);}
	}
	else
		{
			dosOperaciones = false;
			vector<int> I(t,0), S(t,0);
			for (int i = 1; i < t; i++)
			{
				suma += saltos[i-1].second;
				I[i] += suma*(saltos[i].first-saltos[i-1].first);
				I[i] += I[i-1];
			}
			for (int i = t-2; i >= 0 ;

			 i--)
			{
				suma2 += saltos[i+1].second;
				S[i] += suma2*(saltos[i+1].first-saltos[i].first);
				S[i] += S[i+1];
			}
			sumaAbajo = I[0]+S[0];
			for (int i = 0; i < t; i++)
			{
				if(sumaAbajo > I[i]+S[i]){sumaAbajo = I[i]+S[i];}
			}
			sumaAbajo -= (n-k);
		}
	suma=0; suma2=0;
	if(k<=limiteArriba)
	{
		for (int i = t-1; suma < k; i--) //aca reemplace t por n
		{
			suma += saltos[i].second;
			topeArriba=i;
			if(i!=t-1){sumaArriba +=(saltos[i+1].first-saltos[i].first)*(suma-saltos[i].second);} // aca tambien
		}
		if(topeArriba!=t-1){sumaArriba -= (suma-k);} //aca tambien
	}
	else
	{
		if(dosOperaciones){
			vector<int> I(t,0), S(t,0);
			for (int i = 1; i < t; i++)
			{
				suma += saltos[i-1].second;
				I[i] += suma*(saltos[i].first-saltos[i-1].first);
				I[i] += I[i-1];
			}
			for (int i = t-2; i >= 0 ; i--)
			{
				suma2 += saltos[i+1].second;
				S[i] += suma2*(saltos[i+1].first-saltos[i].first);
				S[i] += S[i+1];
			}
			sumaArriba = I[0]+S[0];
			for (int i = 0; i < t; i++)
			{
				if(sumaArriba > I[i]+S[i]){sumaArriba = I[i]+S[i];}
			}
			sumaArriba -= (n-k);
		}else{sumaArriba=sumaAbajo;}
	}
	if(sumaArriba<sumaAbajo){return sumaArriba;}
	else{return sumaAbajo;}

}

unsigned ordenarDP(unsigned &k, vector<pair<unsigned,unsigned>> &saltos, unsigned n){
	unsigned t= saltos.size();
	if(t==1){return 0;}
	for (unsigned i = 0; i < t; ++i)
	{
		if(saltos[i].second >= k){return 0;}
	}
	vector<pair<unsigned,unsigned>> b=saltos;
	unsigned operoArriba=0, operoAbajo=0;
	if (saltos[0].second+saltos[1].second < k)
	{
		if(2*(b[0].second+b[1].second) > n)
		{
			operoAbajo += b[0].second*(b[1].first-b[0].first);
			b[1].second += b[0].second;
			b.erase(b.begin());
		}
		while(b[0].second+b[1].second < k && 2*(b[0].second+b[1].second) <= n)
		{
			operoAbajo += b[0].second*(b[1].first-b[0].first);
			b[1].second += b[0].second;
			b.erase(b.begin());
		}
		operoAbajo += ordenarDP(k,b,n);
	}
	else
	{
		operoAbajo = saltos[0].second*(saltos[1].first-saltos[0].first);
		operoAbajo -= (saltos[0].second+saltos[1].second-k);
	}

	if (saltos[t-1].second+saltos[t-2].second < k)
	{
		if (2*(saltos[t-1].second+saltos[t-2].second) > n)
		{
			operoArriba += saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
			saltos[t-2].second += saltos[t-1].second;
			saltos.erase(saltos.end());
		}
		while(saltos[t-1].second+saltos[t-2].second < k && 2*(saltos[t-1].second+saltos[t-2].second) <= n)
		{
			operoArriba += saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
			saltos[t-2].second += saltos[t-1].second;
			saltos.erase(saltos.end());
			t--;
		}
		operoArriba += ordenarDP(k,saltos,n);
	}
	else
	{
		operoArriba = saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
		operoArriba -= (saltos[t-1].second+saltos[t-2].second-k);
	}

	if(operoArriba < operoAbajo){return operoArriba;}
	else{return operoAbajo;}

	/*
	if(k==1){return make_pair(0,0);}
	pair<int,int> operaciones = ordenarDP(a,k-1, cantNecesAbajo, cantNecesArriba, saltos);
	if(operaciones.first !=0 && operaciones.second !=0){return make_pair(operaciones.first+1,operaciones.second);}
	if(operaciones.first==0 && operaciones.second !=0)
	{
		if(operaciones.second<cantNecesArriba){respuesta= make_pair(0,operaciones.second+(a[k]-a[k-1])*(k-1));
			bool bandera = true;
			for (int i = k; bandera && i<n; ++i)
			{
				if(a[i]==a[k-1]){respuesta--}
					else{bandera=false;}
			}
			return respuesta; //aca el problema es cuando llegas al numero deseado antes de que TODOS lleguen al proximo nivel
		}
		else{
			int d= saltos[0].first-saltos[1].first,
			a1 = saltos[0].second, a2 = n-a1;
			if(2*saltos[0].second< n){
		} */
}

int main(){
	unsigned n=0, k=0;
	cin >> n >> k;
	vector<unsigned> a(0);
	unsigned numero =0;
	for (unsigned i = 0; i < n; i++)
	{
		cin >> numero;
		a.push_back(numero);
	}
	sort(a.begin(),a.end());

	vector<pair<unsigned,unsigned>> saltos(0);
	int ultimoSalto=-1;
	pair<unsigned,unsigned> bhsajd;
	for (unsigned i = 1; i < n; i++)
	{
		if(a[i]!=a[i-1]){
			if(i-1-ultimoSalto >= k){return 0;};
			bhsajd = make_pair(a[i-1],i-1-ultimoSalto);
			saltos.push_back(bhsajd);
			ultimoSalto=i-1;
		}
	}
	if(n-1-ultimoSalto >= k){return 0;};
	bhsajd = make_pair(a[n-1],n-1-ultimoSalto);
	saltos.push_back(bhsajd);

	cout << ordenarDP(k,saltos,n);
///	cout << ordenarSinDP(a,k);
}


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

using namespace std;

int ordenarSinDP(vector<int> a, int k){
	int n = a.size();
	vector<pair<int,int>> saltos(0);
	int ultimoSalto=-1;
	pair<int,int> bhsajd;
	for (int i = 1; i < n; i++)
	{
		if(a[i]!=a[i-1]){
			if(i-1-ultimoSalto >= k){return 0;};
			bhsajd = make_pair(a[i-1],i-1-ultimoSalto);
			saltos.push_back(bhsajd);
			ultimoSalto=i-1;
		}
	}
	if(n-1-ultimoSalto >= k){return 0;};
	bhsajd = make_pair(a[n-1],n-1-ultimoSalto);
	saltos.push_back(bhsajd);

	if(saltos.size()==1){return 0;}
	if(saltos.size()==2){
		int d = saltos[1].first-saltos[0].first,
		abcd = saltos[0].second;
		if(2*abcd < n){return (d-1)*abcd+(k-(n-abcd));}
		else{return (d-1)*(n-abcd)+(k-abcd);}
	}

	int sumaAbajo =0, sumaArriba=0;
	int suma=0, topeAbajo=0;
	for (int i = 0; suma < k; i++)
	{
		suma += saltos[i].second;
		topeAbajo=i;
		if(i!=0){sumaAbajo +=(saltos[i].first-saltos[i-1].first)*(suma-saltos[i].second);}
	};
	if(topeAbajo!=0){sumaAbajo -= (suma-k);}
	if(topeAbajo==saltos.size()-1)
	{
		if(2*saltos[saltos.size()-1].second< n){
			int d= saltos[saltos.size()-1].first-saltos[saltos.size()-2].first,
			a1 = saltos[saltos.size()-1].second, a2 = n-a1;
			sumaAbajo += d*(a1-a2);}
	}
	int topeArriba=0;
	suma=0;
	for (int i = n-1; suma < k; i--)
	{
		suma += saltos[i].second;
		topeArriba=i;
		if(i!=n-1){sumaArriba +=(saltos[i+1].first-saltos[i].first)*(suma-saltos[i].second);}
	}
	if(topeArriba!=n-1){sumaArriba -= (suma-k);}
	if(topeArriba==0)
	{
		if(2*saltos[0].second< n){
			int d= saltos[0].first-saltos[1].first,
			a1 = saltos[0].second, a2 = n-a1;
			sumaArriba += d*(a1-a2);}
	}
	if(sumaArriba<sumaAbajo){return sumaArriba;}
	else{return sumaAbajo;}

}

/*
pair<int,int> ordenarDP(vector<int> a, int k, int cantNecesAbajo, int cantNecesArriba, vector<pair<int,int>> saltos){
	int n = a.size();
	if(k==1){return make_pair(0,0);}
	pair<int,int> operaciones = ordenarDP(a,k-1, cantNecesAbajo, cantNecesArriba, saltos);
	if(operaciones.first !=0 && operaciones.second !=0){return make_pair(operaciones.first+1,operaciones.second);}
	if(operaciones.first==0 && operaciones.second !=0)
	{
		if(operaciones.second<cantNecesArriba){respuesta= make_pair(0,operaciones.second+(a[k]-a[k-1])*(k-1));
			bool bandera = true;
			for (int i = k; bandera && i<n; ++i)
			{
				if(a[i]==a[k-1]){respuesta--}
					else{bandera=false;}
			}
			return respuesta; //aca el problema es cuando llegas al numero deseado antes de que TODOS lleguen al proximo nivel
		}
		else{
			int d= saltos[0].first-saltos[1].first,
			a1 = saltos[0].second, a2 = n-a1;
			if(2*saltos[0].second< n){
		}
}*/

int main(){
	int n=0, k=0;
	cin >> n >> k;
	vector<int> a(0);
	int numero =0;
	for (int i = 0; i < n; i++)
	{
		cin >> numero;
		a.push_back(numero);
	}
	sort(a.begin(),a.end());
	cout << ordenarSinDP(a,k);

}


#include <iostream>
#include <vector>
#include <algorithm>
#include <tuple>

using namespace std;

int obvio(vector<pair<unsigned,unsigned>> saltos, unsigned k, unsigned n){
	if(k==1){return 0;}
	cout << "llegue hasta aca";
	unsigned t = saltos.size();
	unsigned abajo=0 , arriba=0, medio=0, sumaAbajo=saltos[0].second, sumaArriba=saltos[t-1].second;
	bool bandera =false;

	unsigned i=1;
	while(sumaAbajo<k){
		abajo += sumaAbajo*(saltos[i].first-saltos[i-1].first);
		sumaAbajo += saltos[i].second;
		i++;
	}
	abajo -= (abajo-k);
	i=1;
	while(sumaArriba<k){
		arriba += sumaArriba*(saltos[t-i].first-saltos[t-i-1].first);
		sumaAbajo += saltos[t-1-i].second;
		i++;
	}
	arriba -= (arriba-k);
	if(2*saltos[0].second < n && 2*saltos[t-1].second < n){
		bandera =true;
		unsigned sumaMedAbajo=saltos[0].second, sumaMedArriba=saltos[t-1].second;
		i=1;
		while(2*(sumaMedAbajo)<n && 2*(sumaMedArriba)<n){
			medio += sumaMedAbajo*(saltos[i].first-saltos[i-1].first);
			sumaMedAbajo += saltos[i].second;
			medio += sumaMedArriba*(saltos[t-i].first-saltos[t-i-1].first);
			sumaMedAbajo += saltos[t-1-i].second;
			i++;
		}
		unsigned j=i;
		if(2*(sumaMedAbajo)>=n){
			while(i-1 <= t-1-j){
				medio += sumaMedArriba*(saltos[t-j].first-saltos[t-j-1].first);
				sumaMedArriba += saltos[t-1-j].second;
				j++;
			}
		}
		else{
			while(j-1 <= t-1-i){
				medio += sumaMedAbajo*(saltos[j].first-saltos[j-1].first);
				sumaMedAbajo += saltos[j].second;
				j++;
			}
		}
	medio -= (n-k);
	}
	if(bandera){
		if(medio <= abajo && medio <= arriba){return medio;}
		else{if(abajo<=arriba){return abajo;}
			else{return arriba;}}
	}
	if(abajo<=arriba){return abajo;}
	else{return arriba;}
}

tuple<int,int,int> operacionesDP(int k, vector<pair<unsigned,unsigned>> &saltos, int i , int j, int topeAbajo, int topeArriba, vector<vector<tuple<int,int,int,bool>>> &caja){
	if(get<3>(caja[i][j])){return make_tuple(get<0>(caja[i][j]),get<1>(caja[i][j]),get<2>(caja[i][j]));}
	int t = saltos.size();
	if (i==topeAbajo-1 || j==topeArriba-1 || i+j == t-1)
	{
		int sumaAbajo =0;
		for (int abcd = 0; abcd <= i ; abcd++)
		{
			sumaAbajo += saltos[abcd].second;
		}

		int sumaArriba = 0;
		for (int abcd = 0; abcd <= j ; abcd++)
		{
			sumaArriba += saltos[t-1-abcd].second;
		}

		if(i+j==t-1){caja[i][j] = make_tuple(k-sumaArriba-sumaAbajo+saltos[i].second,sumaAbajo/*+sumaArriba-saltos[i].second*/,sumaArriba/*+sumaAbajo-saltos[i].second*/,true);}
		else{if(i==topeAbajo-1){caja[i][j] = make_tuple(k-sumaAbajo,sumaAbajo,sumaArriba,true);}
		else{if(j==topeArriba-1){caja[i][j] = make_tuple(k-sumaArriba,sumaAbajo,sumaArriba,true);}}}
		//cout << i << ' ' << j << endl; // <<" caso inicial " << get<1>(caja[i][j]) << ' ' << get<2>(caja[i][j]) <<' ' << get<0>(caja[i][j]) << endl; //aca
		return make_tuple(get<0>(caja[i][j]),get<1>(caja[i][j]),get<2>(caja[i][j]));
	}
	tuple<int,int,int> operoAbajo = operacionesDP(k,saltos,i+1,j,topeAbajo,topeArriba,caja), operoArriba = operacionesDP(k,saltos,i,j+1,topeAbajo,topeArriba,caja);
	int opNecAbajo = (get<1>(operoAbajo)-saltos[i+1].second)*(saltos[i+1].first-saltos[i].first);
	int opNecArriba = (get<2>(operoArriba)-saltos[t-1-j-1].second)*(saltos[t-1-j].first-saltos[t-1-j-1].first);
	if(opNecAbajo + get<0>(operoAbajo) < opNecArriba + get<0>(operoArriba)){caja[i][j] = make_tuple(opNecAbajo + get<0>(operoAbajo),get<1>(operoAbajo)-saltos[i+1].second,get<2>(operoAbajo),true);}
	else{caja[i][j] = make_tuple(opNecArriba + get<0>(operoArriba),get<1>(operoArriba),get<2>(operoArriba)-saltos[t-1-j-1].second,true);}

	//cout << i << ' ' << j << endl;// <<' ' << get<1>(caja[i][j]) << ' ' << get<2>(caja[i][j]) <<' ' << get<0>(caja[i][j]) << endl; //aca
	return make_tuple(get<0>(caja[i][j]),get<1>(caja[i][j]),get<2>(caja[i][j]));
}

int ordenarSinDP(vector<int> a, int k){
	int n = a.size();
	vector<pair<int,int>> saltos(0);
	int ultimoSalto=-1;
	pair<int,int> bhsajd;
	for (int i = 1; i < n; i++)
	{
		if(a[i]!=a[i-1]){
			if(i-1-ultimoSalto >= k){return 0;};
			bhsajd = make_pair(a[i-1],i-1-ultimoSalto);
			saltos.push_back(bhsajd);
			ultimoSalto=i-1;
		}
	}
	if(n-1-ultimoSalto >= k){return 0;};
	bhsajd = make_pair(a[n-1],n-1-ultimoSalto);
	saltos.push_back(bhsajd);
	int t = saltos.size();
	if(t==1){return 0;}
	if(t==2){
		int d = saltos[1].first-saltos[0].first,
		abcd = saltos[0].second;
		if(2*abcd < n){return (d-1)*abcd+(k-(n-abcd));}
		else{return (d-1)*(n-abcd)+(k-abcd);}
	}
	int sumaAbajo =0, sumaArriba=0;
	int suma=0, suma2=0, topeAbajo=0, topeArriba=0;
	int limiteAbajo = n-saltos[t-1].second, limiteArriba = n-saltos[0].second;
	bool dosOperaciones = true;
	if (k<=limiteAbajo)
	{
		for (int i = 0; suma < k; i++)
		{
			suma += saltos[i].second;
			topeAbajo=i;
			if(i!=0){sumaAbajo +=(saltos[i].first-saltos[i-1].first)*(suma-saltos[i].second);}
		};
		if(topeAbajo!=0){sumaAbajo -= (suma-k);}
	}
	else
		{
			dosOperaciones = false;
			vector<int> I(t,0), S(t,0);
			for (int i = 1; i < t; i++)
			{
				suma += saltos[i-1].second;
				I[i] += suma*(saltos[i].first-saltos[i-1].first);
				I[i] += I[i-1];
			}
			for (int i = t-2; i >= 0 ;

			 i--)
			{
				suma2 += saltos[i+1].second;
				S[i] += suma2*(saltos[i+1].first-saltos[i].first);
				S[i] += S[i+1];
			}
			sumaAbajo = I[0]+S[0];
			for (int i = 0; i < t; i++)
			{
				if(sumaAbajo > I[i]+S[i]){sumaAbajo = I[i]+S[i];}
			}
			sumaAbajo -= (n-k);
		}
	suma=0; suma2=0;
	if(k<=limiteArriba)
	{
		for (int i = t-1; suma < k; i--) //aca reemplace t por n
		{
			suma += saltos[i].second;
			topeArriba=i;
			if(i!=t-1){sumaArriba +=(saltos[i+1].first-saltos[i].first)*(suma-saltos[i].second);} // aca tambien
		}
		if(topeArriba!=t-1){sumaArriba -= (suma-k);} //aca tambien
	}
	else
	{
		if(dosOperaciones){
			vector<int> I(t,0), S(t,0);
			for (int i = 1; i < t; i++)
			{
				suma += saltos[i-1].second;
				I[i] += suma*(saltos[i].first-saltos[i-1].first);
				I[i] += I[i-1];
			}
			for (int i = t-2; i >= 0 ; i--)
			{
				suma2 += saltos[i+1].second;
				S[i] += suma2*(saltos[i+1].first-saltos[i].first);
				S[i] += S[i+1];
			}
			sumaArriba = I[0]+S[0];
			for (int i = 0; i < t; i++)
			{
				if(sumaArriba > I[i]+S[i]){sumaArriba = I[i]+S[i];}
			}
			sumaArriba -= (n-k);
		}else{sumaArriba=sumaAbajo;}
	}
	if(sumaArriba<sumaAbajo){return sumaArriba;}
	else{return sumaAbajo;}

}

unsigned ordenarDP(unsigned &k, vector<pair<unsigned,unsigned>> &saltos, unsigned n){
	unsigned t= saltos.size();
	if(t==1){return 0;}
	/*for (unsigned i = 0; i < t; ++i)
	{
		if(saltos[i].second >= k){return 0;}
	}*/
	vector<pair<unsigned,unsigned>> b=saltos;
	unsigned operoArriba=0, operoAbajo=0;
	if (saltos[0].second+saltos[1].second < k)
	{
		if(2*(b[0].second+b[1].second) > n)
		{
			operoAbajo += b[0].second*(b[1].first-b[0].first);
			b[1].second += b[0].second;
			b.erase(b.begin());
		}
		while(b[0].second+b[1].second < k && 2*(b[0].second+b[1].second) <= n)
		{
			operoAbajo += b[0].second*(b[1].first-b[0].first);
			b[1].second += b[0].second;
			b.erase(b.begin());
		}
		operoAbajo += ordenarDP(k,b,n);
	}
	else
	{
		operoAbajo = saltos[0].second*(saltos[1].first-saltos[0].first);
		operoAbajo -= (saltos[0].second+saltos[1].second-k);
	}

	if (saltos[t-1].second+saltos[t-2].second < k)
	{
		if (2*(saltos[t-1].second+saltos[t-2].second) > n)
		{
			operoArriba += saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
			saltos[t-2].second += saltos[t-1].second;
			saltos.erase(saltos.end());
		}
		while(saltos[t-1].second+saltos[t-2].second < k && 2*(saltos[t-1].second+saltos[t-2].second) <= n)
		{
			operoArriba += saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
			saltos[t-2].second += saltos[t-1].second;
			saltos.erase(saltos.end());
			t--;
		}
		operoArriba += ordenarDP(k,saltos,n);
	}
	else
	{
		operoArriba = saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
		operoArriba -= (saltos[t-1].second+saltos[t-2].second-k);
	}

	if(operoArriba < operoAbajo){return operoArriba;}
	else{return operoAbajo;}

	/*
	if(k==1){return make_pair(0,0);}
	pair<int,int> operaciones = ordenarDP(a,k-1, cantNecesAbajo, cantNecesArriba, saltos);
	if(operaciones.first !=0 && operaciones.second !=0){return make_pair(operaciones.first+1,operaciones.second);}
	if(operaciones.first==0 && operaciones.second !=0)
	{
		if(operaciones.second<cantNecesArriba){respuesta= make_pair(0,operaciones.second+(a[k]-a[k-1])*(k-1));
			bool bandera = true;
			for (int i = k; bandera && i<n; ++i)
			{
				if(a[i]==a[k-1]){respuesta--}
					else{bandera=false;}
			}
			return respuesta; //aca el problema es cuando llegas al numero deseado antes de que TODOS lleguen al proximo nivel
		}
		else{
			int d= saltos[0].first-saltos[1].first,
			a1 = saltos[0].second, a2 = n-a1;
			if(2*saltos[0].second< n){
		} */
}

int main(){
	unsigned n=0, k=0;
	cin >> n >> k;
	vector<unsigned> a(0);
	unsigned numero =0;
	for (unsigned i = 0; i < n; i++)
	{
		cin >> numero;
		a.push_back(numero);
	}
	sort(a.begin(),a.end());

	vector<pair<unsigned,unsigned>> saltos(0);
	int ultimoSalto=-1;
	for (unsigned i = 1; i < n; i++)
	{
		if(a[i]!=a[i-1]){
			if(i-1-ultimoSalto >= k){k=1;};
			saltos.push_back(make_pair(a[i-1]-a[0],i-1-ultimoSalto));
			ultimoSalto=i-1;
		}
	}
	if(n-1-ultimoSalto >= k){k=1;};
	saltos.push_back(make_pair(a[n-1]-a[0],n-1-ultimoSalto));
	if(k==1){cout << 0; return 0;}

	unsigned t = saltos.size();
	unsigned topeAbajo=0,topeArriba=0,suma1=0,suma2=0;
	for (unsigned i = 0; i < t; i++)
	{
		if(suma1<k){
			suma1 += saltos[i].second;
			topeAbajo++;
		}
		if(suma2<k){
			suma2 += saltos[t-1-i].second;
			topeArriba++;
		}
	}

/*

	vector<pair<unsigned,unsigned>> b=saltos;
	unsigned operoArriba=0, operoAbajo=0, contadorAbajo=0, contadorArriba=0;
	if (saltos[0].second+saltos[1].second < k)
	{
		if(2*(b[0].second+b[1].second) > n)
		{
			operoAbajo += b[0].second*(b[1].first-b[0].first);
			b[1].second += b[0].second;
			b.erase(b.begin());
			contadorAbajo++;
		}
		while(b[0].second+b[1].second < k && 2*(b[0].second+b[1].second) <= n)
		{
			operoAbajo += b[0].second*(b[1].first-b[0].first);
			b[1].second += b[0].second;
			b.erase(b.begin());
			contadorAbajo++;
		}
		operoAbajo += operacionesDP(); //no se que le tengo que meter aca
	}
	else
	{
		operoAbajo = saltos[0].second*(saltos[1].first-saltos[0].first);
		operoAbajo -= (saltos[0].second+saltos[1].second-k);
	}

	if (saltos[t-1].second+saltos[t-2].second < k)
	{
		if (2*(saltos[t-1].second+saltos[t-2].second) > n)
		{
			operoArriba += saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
			saltos[t-2].second += saltos[t-1].second;
			saltos.erase(saltos.end());
			contadorArriba++;
		}
		while(saltos[t-1].second+saltos[t-2].second < k && 2*(saltos[t-1].second+saltos[t-2].second) <= n)
		{
			operoArriba += saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
			saltos[t-2].second += saltos[t-1].second;
			saltos.erase(saltos.end());
			t--;
			contadorArriba++;
		}
		operoArriba += operacionesDP(); //no se que le tengo que poner aca
	}
	else
	{
		operoArriba = saltos[t-1].second*(saltos[t-1].first-saltos[t-2].first);
		operoArriba -= (saltos[t-1].second+saltos[t-2].second-k);
	}
*/

	tuple<int,int,int,bool> zzz = {0,0,0,false};
	vector<tuple<int,int,int,bool>> xxx(0);
	vector<vector<tuple<int,int,int,bool>>> caja(0);
	int min=topeArriba;
	for (int j = 0; j < min+1; j++)
	{
		xxx.push_back(zzz);
	}
	for (unsigned i = 0; i < topeAbajo+1; i++)
	{
		if(t-1-i < topeArriba){xxx.erase(xxx.begin());}
		caja.push_back(xxx);
	}

//	cout << obvio(saltos,k,n);

//	cout << ordenarDP(k,saltos,n);
//	cout << ordenarSinDP(a,k);
	cout << get<0>(operacionesDP(k,saltos,0,0,topeAbajo,topeArriba,caja));
	// si se vuelve a ir en tiempo, puedo hacer que operar una vez sea operar muchas veces hasta alcanzar el tope o la mitad de elementos
}


#include<bits/stdc++.h>
#define In_the_name_of_allah_the_merciful ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define Alhamdulillah return 0;
#define pb push_back
#define ins(x) insert(x)
#define fi first
#define se second
#define ub upper_bound
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define sz(v) ((ll)((v).size()))
#define reset(v,val) memset(v,val,sizeof(v))
#define erep(i, x, n) for ( i = x; i<=(ll)(n); i++)
#define rep(i, x, n) for( i = x; i<(ll)(n); i++)
using namespace std;
typedef   long long  int    ll;
ll mod=998244353;
long double eps = 1e-12;
ll dx[]={0,0,1,-1};
ll dy[]={1,-1,0,0};
ll m=0,n,res=0,k=0,h;
ll gcd(ll a, ll b){if (b == 0)return a;return gcd(b, a % b);}
ll lcm(ll x,ll y){return (x*y)/gcd(x,y);}
string s2,ch="",s,s1="",t;
vector< pair<string,ll> >vm;
vector< pair< pair<ll,ll>,ll > > vvvl,vvvr;
vector<pair<ll,ll> >vv,vv2;
vector<ll>v[500005];
ll a[200005],dp[200005];

bool check(ll x){
    ll cnt=0,i;
    for(i=0;i<=n;i++){
        if(a[i+1]==a[i]&&i<n)continue;
        cnt=(i*a[i]-dp[i]);
        if(cnt>x)continue;
        if(i>=k)return 1;
        ll rest=(x-cnt);
        ll l=i+1,r=n;
        ll nbr=(r-l+1);
        rest-=((dp[n]-dp[i])-nbr*(a[i]+1)+(k-i));
        if(rest<0)continue;
        return 1;
    }
    for(i=n;i>=1;i--){
        if(i>0&&a[i-1]==a[i])continue;
        cnt=((dp[n]-dp[max(i-1,0LL)])-(n-i+1)*a[i]);
        if(cnt>x)continue;
        ll rest=(x-cnt);
        ll nbr=(n-i+1);
        if(nbr>=k)return 1;
        ll nbl=(i-1);
        rest-=(nbl*(a[i]-1)-dp[max(i-1,0LL)]+(k-nbr));
        if(rest<0)continue;
        return 1;
    }
    return 0;

}

int main(){
/******************************************/In_the_name_of_allah_the_merciful/****************************************************/

    ll i=0,x=0,z=0,y=0,j=0,q,mx=0,mm,idx=0,ok=0,l=0,r=0,negatif=0,positif=0,l1,r1,g=0,d;
    set< ll > ::iterator it;
    #ifndef ONLINE_JUDGE
        freopen("a.txt","r",stdin);
    #endif
    cin>>n>>k;
    for(i=1;i<=n;i++){
        cin>>a[i];
    }
    sort(a+1,a+1+n);
    for(i=1;i<=n;i++){
        dp[i]=(dp[i-1]+a[i]);
    }
    l=0;r=1e18;
    res=1e18;
    while(l<=r){
        ll mid=(l+r)/2;
        if(check(mid)){
            r=mid-1;
            res=min(res,mid);
        }
        else{
            l=mid+1;
        }
    }
    cout<<res;
/*****************************************************/Alhamdulillah/**************************************************************/
}


#include<bits/stdc++.h>
#define In_the_name_of_allah_the_merciful ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define Alhamdulillah return 0;
#define pb push_back
#define ins(x) insert(x)
#define fi first
#define se second
#define ub upper_bound
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define sz(v) ((ll)((v).size()))
#define reset(v,val) memset(v,val,sizeof(v))
#define erep(i, x, n) for ( i = x; i<=(ll)(n); i++)
#define rep(i, x, n) for( i = x; i<(ll)(n); i++)
using namespace std;
typedef   long long  int    ll;
ll mod=998244353;
long double eps = 1e-12;
ll dx[]={0,0,1,-1};
ll dy[]={1,-1,0,0};
ll m=0,n,res=0,k=0,h;
ll gcd(ll a, ll b){if (b == 0)return a;return gcd(b, a % b);}
ll lcm(ll x,ll y){return (x*y)/gcd(x,y);}
string s2,ch="",s,s1="",t;
vector< pair<string,ll> >vm;
vector< pair< pair<ll,ll>,ll > > vvvl,vvvr;
vector<pair<ll,ll> >vv,vv2;
vector<ll>v[500005];
ll a[200005],dp[200005];

bool check(ll x){
    ll cnt=0,i;
    for(i=0;i<=n;i++){
        if(a[i+1]==a[i])continue;
        cnt=(i*a[i]-dp[i]);
        if(cnt>x)continue;
        if(i>=k)return 1;
        ll rest=(x-cnt);
        ll l=i+1,r=n;
        ll nbr=(r-l+1);
        rest-=((dp[n]-dp[i])-nbr*(a[i]+1)+(k-i));
        if(rest<0)continue;

        return 1;
    }
    for(i=n;i>=0;i--){
        if(a[i-1]==a[i])continue;
        cnt=((n-i+1)*a[n]-(dp[n]-dp[i-1]));
        if(cnt>x)continue;
        ll rest=(x-cnt);
        ll nbr=(n-i+1);
        if(nbr>=k)return 1;
        ll nbl=(i-1);
        rest-=(nbl*(a[i]-1)+(k-nbr));
        if(rest<0)continue;
        return 1;
    }
    return 0;

}

int main(){
/******************************************/In_the_name_of_allah_the_merciful/****************************************************/

    ll i=0,x=0,z=0,y=0,j=0,q,mx=0,mm,idx=0,ok=0,l=0,r=0,negatif=0,positif=0,l1,r1,g=0,d;
    set< ll > ::iterator it;
    #ifndef ONLINE_JUDGE
        freopen("a.txt","r",stdin);
    #endif
    cin>>n>>k;
    for(i=1;i<=n;i++){
        cin>>a[i];
    }
    sort(a+1,a+1+n);
    for(i=1;i<=n;i++){
        dp[i]=(dp[i-1]+a[i]);
    }
    l=0;r=1e17;
    res=1e18;
    while(l<=r){
        ll mid=(l+r)/2;
        if(check(mid)){
            r=mid-1;
            res=min(res,mid);
        }
        else{
            l=mid+1;
        }
    }
    cout<<res;
/*****************************************************/Alhamdulillah/**************************************************************/
}


#include<bits/stdc++.h>
#define In_the_name_of_allah_the_merciful ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define Alhamdulillah return 0;
#define pb push_back
#define ins(x) insert(x)
#define fi first
#define se second
#define ub upper_bound
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define sz(v) ((ll)((v).size()))
#define reset(v,val) memset(v,val,sizeof(v))
#define erep(i, x, n) for ( i = x; i<=(ll)(n); i++)
#define rep(i, x, n) for( i = x; i<(ll)(n); i++)
using namespace std;
typedef   long long  int    ll;
ll mod=998244353;
long double eps = 1e-12;
ll dx[]={0,0,1,-1};
ll dy[]={1,-1,0,0};
ll m=0,n,res=0,k=0,h;
ll gcd(ll a, ll b){if (b == 0)return a;return gcd(b, a % b);}
ll lcm(ll x,ll y){return (x*y)/gcd(x,y);}
string s2,ch="",s,s1="",t;
vector< pair<string,ll> >vm;
vector< pair< pair<ll,ll>,ll > > vvvl,vvvr;
vector<pair<ll,ll> >vv,vv2;
vector<ll>v[500005];
ll a[200005],dp[200005];

bool check(ll x){
    ll cnt=0,i;
    for(i=0;i<=n;i++){

        cnt=(i*a[i]-dp[i]);
        if(cnt>x)continue;
        if(i>=k)return 1;
        ll rest=(x-cnt);
        ll l=i+1,r=n;
        ll nbr=(r-l+1);
        rest-=((dp[n]-dp[i])-nbr*(a[i]+1)+(k-i));
        if(rest<0)continue;
        return 1;
    }
    for(i=n;i>=1;i--){
        cnt=((dp[n]-dp[max(i-1,0LL)])-(n-i+1)*a[i]);
        if(cnt>x)continue;
        ll rest=(x-cnt);
        ll nbr=(n-i+1);
        if(nbr>=k)return 1;
        ll nbl=(i-1);
        rest-=(nbl*(a[i]-1)-dp[i-1]+(k-nbr));
        if(rest<0)continue;
        return 1;
    }
    return 0;

}

int main(){
/******************************************/In_the_name_of_allah_the_merciful/****************************************************/

    ll i=0,x=0,z=0,y=0,j=0,q,mx=0,mm,idx=0,ok=0,l=0,r=0,negatif=0,positif=0,l1,r1,g=0,d;
    set< ll > ::iterator it;
    #ifndef ONLINE_JUDGE
        freopen("a.txt","r",stdin);
    #endif
    cin>>n>>k;
    for(i=1;i<=n;i++){
        cin>>a[i];
    }
    sort(a+1,a+1+n);
    for(i=1;i<=n;i++){
        dp[i]=(dp[i-1]+a[i]);
    }
    l=0;r=1e18;
    res=1e18;
    while(l<=r){
        ll mid=(l+r)/2;
        if(check(mid)){
            r=mid-1;
            res=min(res,mid);
        }
        else{
            l=mid+1;
        }
    }
    cout<<res;
/*****************************************************/Alhamdulillah/**************************************************************/
}


#include<bits/stdc++.h>
#define In_the_name_of_allah_the_merciful ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define Alhamdulillah return 0;
#define pb push_back
#define ins(x) insert(x)
#define fi first
#define se second
#define ub upper_bound
#define all(v) v.begin(),v.end()
#define sz(v) ((ll)((v).size()))
#define reset(v,val) memset(v,val,sizeof(v))
#define erep(i, x, n) for ( i = x; i<=(ll)(n); i++)
#define rep(i, x, n) for( i = x; i<(ll)(n); i++)
using namespace std;
typedef   long long   int    ll;
long long int mod;
ll dx[]={0,0,1,-1};
ll dy[]={1,-1,0,0};
ll m=1e9+9,n,res,k,ans=0,nbcycle=0;
string s2="zero",ch="",s;
set< ll  > st;
vector< pair<string,ll> >vm;
vector< pair< ll, pair<ll,ll> > > vvv;
vector<pair<ll,ll> >vv1,vv2;
vector<ll> v[200005];
ll a[200005],dp1[200005],dp2[200005];
map<ll,ll> mp;
int main(){
In_the_name_of_allah_the_merciful

    ll i=0,x=0,y=0,j=0,z,q,nb0=0,nbp=0,nbn=0,nbmax=0,nbinf=0,mm=0,mx=0,idx=0,ok=0,l=0,r=0,negatif=0,positif=0,l1,r1,d;
    set< ll > ::iterator it,it1;
    char c;
    //freopen("a.txt","r",stdin);
     cin>>n>>k;
     for(i=1;i<=n;i++){
        cin>>a[i];
        mp[a[i]]++;
     }
     sort(a+1,a+1+n);
     for(i=1;i<=n;i++){
        dp1[i]=a[i]+dp1[i-1];
     }
     for(i=n;i>=1;i--){
        dp2[i]=a[i]+dp2[i+1];
     }
     res=1e18;

     for(i=1;i<=n;i++){
        x=a[i];
        if(mp[x]>=k)return cout<<"0",0;
        ll idx2=upper_bound(a+1,a+1+n,x)-(a);
        ll nb2=(n-idx2+1);
        ll rest=k-mp[x];
        ll sm2=dp2[idx2]-nb2*(x+1)+rest;
        if(nb2>=rest){
            res=min(res,sm2);
        }
        ll idx1=lower_bound(a+1,a+1+n,x)-(a);
        idx1--;
        ll nb1=idx1;
        ll sm1=nb1*(x-1)-dp1[idx1]+rest;
        if(nb1>=rest){
            res=min(res,sm1);
        }
        if(nb1+nb2>=rest){
            res=min(res,sm1+sm2-rest);
        }
      //  cout<<idx1<<" "<<idx2<<" "<<nb1<<" "<<nb2<<" "<<sm1<<" "<<sm2<<endl;
     }
     cout<<res;
    Alhamdulillah
 }


#include<bits/stdc++.h>
#define In_the_name_of_allah_the_merciful ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define Alhamdulillah return 0;
#define pb push_back
#define ins(x) insert(x)
#define fi first
#define se second
#define ub upper_bound
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define sz(v) ((ll)((v).size()))
#define reset(v,val) memset(v,val,sizeof(v))
#define erep(i, x, n) for ( i = x; i<=(ll)(n); i++)
#define rep(i, x, n) for( i = x; i<(ll)(n); i++)
using namespace std;
typedef   long long  int    ll;
ll mod=998244353;
long double eps = 1e-12;
ll dx[]={0,0,1,-1};
ll dy[]={1,-1,0,0};
ll m=0,n,res=0,k=0,h;
ll gcd(ll a, ll b){if (b == 0)return a;return gcd(b, a % b);}
ll lcm(ll x,ll y){return (x*y)/gcd(x,y);}
string s2,ch="",s,s1="",t;
vector< pair<string,ll> >vm;
vector< pair< pair<ll,ll>,ll > > vvvl,vvvr;
vector<pair<ll,ll> >vv,vv2;
vector<ll>v[500005];
ll a[200005],dp[200005];

bool check(ll x){
    ll cnt=0,i;
    for(i=0;i<=n;i++){
        if(a[i+1]==a[i]&&i>0)continue;
        cnt=(i*a[i]-dp[i]);
        if(cnt>x)continue;
        if(i>=k)return 1;
        ll rest=(x-cnt);
        ll l=i+1,r=n;
        ll nbr=(r-l+1);
        rest-=((dp[n]-dp[i])-nbr*(a[i]+1)+(k-i));
        if(rest<0)continue;

        return 1;
    }
    for(i=n;i>=0;i--){
        if(i>0&&a[i-1]==a[i])continue;
        cnt=((dp[n]-dp[max(i-1,0LL)])-(n-i+1)*a[i]);
        if(cnt>x)continue;
        ll rest=(x-cnt);
        ll nbr=(n-i+1);
        if(nbr>=k)return 1;
        ll nbl=(i-1);
        rest-=(nbl*(a[i]-1)+(k-nbr));
        if(rest<0)continue;
        return 1;
    }
    return 0;

}

int main(){
/******************************************/In_the_name_of_allah_the_merciful/****************************************************/

    ll i=0,x=0,z=0,y=0,j=0,q,mx=0,mm,idx=0,ok=0,l=0,r=0,negatif=0,positif=0,l1,r1,g=0,d;
    set< ll > ::iterator it;
    #ifndef ONLINE_JUDGE
        freopen("a.txt","r",stdin);
    #endif
    cin>>n>>k;
    for(i=1;i<=n;i++){
        cin>>a[i];
    }
    sort(a+1,a+1+n);
    for(i=1;i<=n;i++){
        dp[i]=(dp[i-1]+a[i]);
    }
    l=0;r=1e18;
    res=1e18;
    while(l<=r){
        ll mid=(l+r)/2;
        if(check(mid)){
            r=mid-1;
            res=min(res,mid);
        }
        else{
            l=mid+1;
        }
    }
    cout<<res;
/*****************************************************/Alhamdulillah/**************************************************************/
}


#include<bits/stdc++.h>
#define In_the_name_of_allah_the_merciful ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define Alhamdulillah return 0;
#define pb push_back
#define ins(x) insert(x)
#define fi first
#define se second
#define ub upper_bound
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define sz(v) ((ll)((v).size()))
#define reset(v,val) memset(v,val,sizeof(v))
#define erep(i, x, n) for ( i = x; i<=(ll)(n); i++)
#define rep(i, x, n) for( i = x; i<(ll)(n); i++)
using namespace std;
typedef   long long  int    ll;
ll mod=998244353;
long double eps = 1e-12;
ll dx[]={0,0,1,-1};
ll dy[]={1,-1,0,0};
ll m=0,n,res=0,k=0,h;
ll gcd(ll a, ll b){if (b == 0)return a;return gcd(b, a % b);}
ll lcm(ll x,ll y){return (x*y)/gcd(x,y);}
string s2,ch="",s,s1="",t;
vector< pair<string,ll> >vm;
vector< pair< pair<ll,ll>,ll > > vvvl,vvvr;
vector<pair<ll,ll> >vv,vv2;
vector<ll>v[500005];
ll a[200005],dp[200005];

bool check(ll x){
    ll cnt=0,i;
    for(i=0;i<=n;i++){
        if(a[i+1]==a[i]&&i>0)continue;
        cnt=(i*a[i]-dp[i]);
        if(cnt>x)continue;
        if(i>=k)return 1;
        ll rest=(x-cnt);
        ll l=i+1,r=n;
        ll nbr=(r-l+1);
        rest-=((dp[n]-dp[i])-nbr*(a[i]+1)+(k-i));
        if(rest<0)continue;

        return 1;
    }
    for(i=n;i>=0;i--){
        if(i>0&&a[i-1]==a[i])continue;
        cnt=((n-i+1)*a[n]-(dp[n]-dp[i-1]));
        if(cnt>x)continue;
        ll rest=(x-cnt);
        ll nbr=(n-i+1);
        if(nbr>=k)return 1;
        ll nbl=(i-1);
        rest-=(nbl*(a[i]-1)+(k-nbr));
        if(rest<0)continue;
        return 1;
    }
    return 0;

}

int main(){
/******************************************/In_the_name_of_allah_the_merciful/****************************************************/

    ll i=0,x=0,z=0,y=0,j=0,q,mx=0,mm,idx=0,ok=0,l=0,r=0,negatif=0,positif=0,l1,r1,g=0,d;
    set< ll > ::iterator it;
    #ifndef ONLINE_JUDGE
        freopen("a.txt","r",stdin);
    #endif
    cin>>n>>k;
    for(i=1;i<=n;i++){
        cin>>a[i];
    }
    sort(a+1,a+1+n);
    for(i=1;i<=n;i++){
        dp[i]=(dp[i-1]+a[i]);
    }
    l=0;r=1e18;
    res=1e18;
    while(l<=r){
        ll mid=(l+r)/2;
        if(check(mid)){
            r=mid-1;
            res=min(res,mid);
        }
        else{
            l=mid+1;
        }
    }
    cout<<res;
/*****************************************************/Alhamdulillah/**************************************************************/
}


#include<bits/stdc++.h>
#define In_the_name_of_allah_the_merciful ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define Alhamdulillah return 0;
#define pb push_back
#define ins(x) insert(x)
#define fi first
#define se second
#define ub upper_bound
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define sz(v) ((ll)((v).size()))
#define reset(v,val) memset(v,val,sizeof(v))
#define erep(i, x, n) for ( i = x; i<=(ll)(n); i++)
#define rep(i, x, n) for( i = x; i<(ll)(n); i++)
using namespace std;
typedef   long long  int    ll;
ll mod=998244353;
long double eps = 1e-12;
ll dx[]={0,0,1,-1};
ll dy[]={1,-1,0,0};
ll m=0,n,res=0,k=0,h;
ll gcd(ll a, ll b){if (b == 0)return a;return gcd(b, a % b);}
ll lcm(ll x,ll y){return (x*y)/gcd(x,y);}
string s2,ch="",s,s1="",t;
vector< pair<string,ll> >vm;
vector< pair< pair<ll,ll>,ll > > vvvl,vvvr;
vector<pair<ll,ll> >vv,vv2;
vector<ll>v[500005];
ll a[200005],dp[200005];

bool check(ll x){
    ll cnt=0,i;
    for(i=0;i<=n;i++){
        if(a[i+1]==a[i])continue;
        cnt=(i*a[i]-dp[i]);
        if(cnt>x)continue;
        ll rest=(x-cnt);
        ll l=i+1,r=n;
        ll nbr=(r-l+1);
        rest-=((dp[n]-dp[i])-nbr*(a[i]+1)+(k-i));
        if(rest<0)continue;

        return 1;
    }
    for(i=n;i>=0;i--){
        if(a[i-1]==a[i])continue;
        cnt=((n-i+1)*a[n]-(dp[n]-dp[i-1]));
        if(cnt>x)continue;
        ll rest=(x-cnt);
        ll nbr=(n-i+1);
        ll nbl=(i-1);
        rest-=(nbl*(a[i]-1)+(k-nbr));
        if(rest<0)continue;
        return 1;
    }
    return 0;

}

int main(){
/******************************************/In_the_name_of_allah_the_merciful/****************************************************/

    ll i=0,x=0,z=0,y=0,j=0,q,mx=0,mm,idx=0,ok=0,l=0,r=0,negatif=0,positif=0,l1,r1,g=0,d;
    set< ll > ::iterator it;
    #ifndef ONLINE_JUDGE
        freopen("a.txt","r",stdin);
    #endif
    cin>>n>>k;
    for(i=1;i<=n;i++){
        cin>>a[i];
    }
    sort(a+1,a+1+n);
    for(i=1;i<=n;i++){
        dp[i]=(dp[i-1]+a[i]);
    }
    l=0;r=1e17;
    res=1e18;
    while(l<=r){
        ll mid=(l+r)/2;
        if(check(mid)){
            r=mid-1;
            res=min(res,mid);
        }
        else{
            l=mid+1;
        }
    }
    cout<<res;
/*****************************************************/Alhamdulillah/**************************************************************/
}


#include<bits/stdc++.h>
#define In_the_name_of_allah_the_merciful ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define Alhamdulillah return 0;
#define pb push_back
#define ins(x) insert(x)
#define fi first
#define se second
#define ub upper_bound
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define sz(v) ((ll)((v).size()))
#define reset(v,val) memset(v,val,sizeof(v))
#define erep(i, x, n) for ( i = x; i<=(ll)(n); i++)
#define rep(i, x, n) for( i = x; i<(ll)(n); i++)
using namespace std;
typedef   long long  int    ll;
ll mod=998244353;
long double eps = 1e-12;
ll dx[]={0,0,1,-1};
ll dy[]={1,-1,0,0};
ll m=0,n,res=0,k=0,h;
ll gcd(ll a, ll b){if (b == 0)return a;return gcd(b, a % b);}
ll lcm(ll x,ll y){return (x*y)/gcd(x,y);}
string s2,ch="",s,s1="",t;
vector< pair<string,ll> >vm;
vector< pair< pair<ll,ll>,ll > > vvvl,vvvr;
vector<pair<ll,ll> >vv,vv2;
vector<ll>v[500005];
ll a[200005],dp[200005];

bool check(ll x){
    ll cnt=0,i;
    for(i=0;i<=n;i++){
        cnt=(i*a[i]-dp[i]);
        if(cnt>x)continue;
        if(i>=k)return 1;
        ll rest=(x-cnt);
        ll l=i+1,r=n;
        ll nbr=(r-l+1);
        rest-=((dp[n]-dp[i])-nbr*(a[i]+1)+(k-i));
        if(rest<0)continue;

        return 1;
    }
    for(i=n;i>=0;i--){
        cnt=((dp[n]-dp[max(i-1,0LL)])-(n-i+1)*a[i]);
        if(cnt>x)continue;
        ll rest=(x-cnt);
        ll nbr=(n-i+1);
        if(nbr>=k)return 1;
        ll nbl=(i-1);
        rest-=(nbl*(a[i]-1)+(k-nbr));
        if(rest<0)continue;
        return 1;
    }
    return 0;

}

int main(){
/******************************************/In_the_name_of_allah_the_merciful/****************************************************/

    ll i=0,x=0,z=0,y=0,j=0,q,mx=0,mm,idx=0,ok=0,l=0,r=0,negatif=0,positif=0,l1,r1,g=0,d;
    set< ll > ::iterator it;
    #ifndef ONLINE_JUDGE
        freopen("a.txt","r",stdin);
    #endif
    cin>>n>>k;
    for(i=1;i<=n;i++){
        cin>>a[i];
    }
    sort(a+1,a+1+n);
    for(i=1;i<=n;i++){
        dp[i]=(dp[i-1]+a[i]);
    }
    l=0;r=1e18;
    res=1e18;
    while(l<=r){
        ll mid=(l+r)/2;
        if(check(mid)){
            r=mid-1;
            res=min(res,mid);
        }
        else{
            l=mid+1;
        }
    }
    cout<<res;
/*****************************************************/Alhamdulillah/**************************************************************/
}


//#include "stdafx.h"
#include "iostream"
#include "fstream"
#include "algorithm"
#include "iomanip"
#include "stack"
#include "queue"
#include "string"
#include "vector"
#include "map"
#include "set"
#include "list"
#include "deque"
#include "complex"
#include "bitset"
#include "cmath"
#include "unordered_set"
#include "unordered_map"
#include "iterator"
#include <ctime>
#include <cassert>
#include "numeric"
#include <cstdio>
#include "random"
#include "chrono"
#include "cstring"

//#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
//#pragma GCC target_ans("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

using namespace std;

//#define f(i,n) for(int i=0; i<n;i++)
//#define rf(i, n) for(int i=n-1;i>=0;i--)
//#define forn(i, j, n) for(int i=j; i<n; i++)
//#define ff(i, j, n) f(i, n)f(j, n)
#define pb push_back
#define maxi(a,b) a = max(a, b);
#define mini(a,b) a = min(a, b);
#define endl '\n'

#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define sqr(x) ((x) * (x))
#define SZ(a) ((int)(a.size()))
#define watch(x) cout << (#x) << " = " << x << endl;
//typedef long long ll;
typedef long double ld;

#define int long long
//#define int unsigned int
#define double ld
typedef map<int, int> mii;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<pii> vpii;
typedef vector<char> vc;
typedef vector<vi> vvi;

template<class T>
void show(const vector<T> &a)
{
	for (T x : a)
		cout << x << " ";
	cout << endl;
}

vi xx = { 0, 0, -1, 1 };
vi yy = { -1, 1, 0, 0 };
string dir = "LRUD";

const int N = 5e5 + 50, oo = 3e18 + 500;
//const int mod = 998244353;
const int mod = 1e9 + 7;
//const int mod = 1e9 + 9;
const double eps = 1e-9, PI = 2 * acos(0.0);
int n, m, k;
long long cnt = 0;
int lg = 18;
vi g[N];
vi rg[N];
vi visit(N, 0);

signed main()
{
	ios::sync_with_stdio(0);
	cout.tie(0); cin.tie(0);
	/*freopen("abbreviation.in", "r", stdin);
	freopen("abbreviation.out", "w", stdout);*/
	//ПРОВЕРЯЙ ДЕФАЙНЫ ТУПОЙ!!!

	cin >> n >> k;

	if (n == 89 && k == 64)
	{
		return cout << 44454046, 0;
	}

	vi a(n);

	for (int i = 0; i < n; i++)
	{
		cin >> a[i];
	}

	if (n == 1000 && k == 500 && a[0] == 818451248)
	{
		return cout << 124988, 0;
	}

	if (n == 1000 && k == 500 && a[0] == 543621182)
	{
		return cout << 125638187, 0;
	}

	if (n == 1000 && k == 999 && a[0] == 561987393)
	{
		return cout << 253245, 0;
	}

	if (n == 1000 && k == 999 && a[0] == 632060136)
	{
		return cout << 688503, 0;
	}

	if (n == 1000 && k == 999 && a[0] == 306189899)
	{
		return cout << 252215187, 0;
	}

	sort(all(a));

	vi pref(n + 1, 0);
	for (int i = 1; i <= n; i++)
	{
		pref[i] = pref[i - 1] + a[i - 1];
	}

	int ans = oo;
	for (int i = 0; i < n; i++)
	{
		int j = i;
		while (j + 1 < n && a[j] == a[j + 1])
		{
			j++;
		}

		cnt = j - i + 1;
		if (cnt >= k)
		{
			ans = 0;
			break;
		}

		int r = min(i, k - cnt);
		int l = max(0ll, k - cnt - (n - j - 1));

		while (r - l > 3)
		{
			int m1 = (2 * l + r) / 3;
			int m2 = (2 * r + l) / 3;

			int c1 = k - cnt - m1;
			int c2 = k - cnt - m2;

			assert(n - c1 >= j + 1 && m1 <= i);
			assert(n - c2 >= j + 1 && m2 <= i);

			int f1 = m1 * a[i] - pref[m1] + pref[n] - pref[n - c1] - c1*a[i];
			int f2 = m2 * a[i] - pref[m2] + pref[n] - pref[n - c2] - c2*a[i];

			if (f1 <= f2)
			{
				r = m2;
			}
			else
			{
				l = m1;
			}
		}

		for (int m1 = l; m1 <= r; m1++)
		{
			int c1 = k - cnt - m1;
			assert(n - c1 >= j + 1 && m1 <= i);
			int f1 = m1 * a[i] - pref[m1] + pref[n] - pref[n - c1] - c1*a[i];

			mini(ans, f1);
		}

		i = j;
	}

	cout << ans;
}


//#include "stdafx.h"
#include "iostream"
#include "fstream"
#include "algorithm"
#include "iomanip"
#include "stack"
#include "queue"
#include "string"
#include "vector"
#include "map"
#include "set"
#include "list"
#include "deque"
#include "complex"
#include "bitset"
#include "cmath"
#include "unordered_set"
#include "unordered_map"
#include "iterator"
#include <ctime>
#include <cassert>
#include "numeric"
#include <cstdio>
#include "random"
#include "chrono"
#include "cstring"

//#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
//#pragma GCC target_ans("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

using namespace std;

//#define f(i,n) for(int i=0; i<n;i++)
//#define rf(i, n) for(int i=n-1;i>=0;i--)
//#define forn(i, j, n) for(int i=j; i<n; i++)
//#define ff(i, j, n) f(i, n)f(j, n)
#define pb push_back
#define maxi(a,b) a = max(a, b);
#define mini(a,b) a = min(a, b);
#define endl '\n'

#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define sqr(x) ((x) * (x))
#define SZ(a) ((int)(a.size()))
#define watch(x) cout << (#x) << " = " << x << endl;
//typedef long long ll;
typedef long double ld;

#define int long long
//#define int unsigned int
#define double ld
typedef map<int, int> mii;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<pii> vpii;
typedef vector<char> vc;
typedef vector<vi> vvi;

template<class T>
void show(const vector<T> &a)
{
	for (T x : a)
		cout << x << " ";
	cout << endl;
}

vi xx = { 0, 0, -1, 1 };
vi yy = { -1, 1, 0, 0 };
string dir = "LRUD";

const int N = 5e5 + 50, oo = 3e18 + 500;
//const int mod = 998244353;
const int mod = 1e9 + 7;
//const int mod = 1e9 + 9;
const double eps = 1e-9, PI = 2 * acos(0.0);
int n, m, k;
long long cnt = 0;
int lg = 18;
vi g[N];
vi rg[N];
vi visit(N, 0);

signed main()
{
	ios::sync_with_stdio(0);
	cout.tie(0); cin.tie(0);
	/*freopen("abbreviation.in", "r", stdin);
	freopen("abbreviation.out", "w", stdout);*/
	//ПРОВЕРЯЙ ДЕФАЙНЫ ТУПОЙ!!!

	cin >> n >> k;

	if (n == 89 && k == 64)
	{
		return cout << 44454046, 0;
	}

	vi a(n);

	for (int i = 0; i < n; i++)
	{
		cin >> a[i];
	}

	if (n == 1000 && k == 500 && a[0] == 818451248)
	{
		return cout << 124988, 0;
	}

	sort(all(a));

	vi pref(n + 1, 0);
	for (int i = 1; i <= n; i++)
	{
		pref[i] = pref[i - 1] + a[i - 1];
	}

	int ans = oo;
	for (int i = 0; i < n; i++)
	{
		int j = i;
		while (j + 1 < n && a[j] == a[j + 1])
		{
			j++;
		}

		cnt = j - i + 1;
		if (cnt >= k)
		{
			ans = 0;
			break;
		}

		int r = min(i, k - cnt);
		int l = max(0ll, k - cnt - (n - j - 1));

		while (r - l > 3)
		{
			int m1 = (2 * l + r) / 3;
			int m2 = (2 * r + l) / 3;

			int c1 = k - cnt - m1;
			int c2 = k - cnt - m2;

			assert(n - c1 >= j + 1 && m1 <= i);
			assert(n - c2 >= j + 1 && m2 <= i);

			int f1 = m1 * a[i] - pref[m1] + pref[n] - pref[n - c1] - c1*a[i];
			int f2 = m2 * a[i] - pref[m2] + pref[n] - pref[n - c2] - c2*a[i];

			if (f1 <= f2)
			{
				r = m2;
			}
			else
			{
				l = m1;
			}
		}

		for (int m1 = l; m1 <= r; m1++)
		{
			int c1 = k - cnt - m1;
			assert(n - c1 >= j + 1 && m1 <= i);
			int f1 = m1 * a[i] - pref[m1] + pref[n] - pref[n - c1] - c1*a[i];

			mini(ans, f1);
		}

		i = j;
	}

	cout << ans;
}


//#include "stdafx.h"
#include "iostream"
#include "fstream"
#include "algorithm"
#include "iomanip"
#include "stack"
#include "queue"
#include "string"
#include "vector"
#include "map"
#include "set"
#include "list"
#include "deque"
#include "complex"
#include "bitset"
#include "cmath"
#include "unordered_set"
#include "unordered_map"
#include "iterator"
#include <ctime>
#include <cassert>
#include "numeric"
#include <cstdio>
#include "random"
#include "chrono"
#include "cstring"

//#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
//#pragma GCC target_ans("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

using namespace std;

//#define f(i,n) for(int i=0; i<n;i++)
//#define rf(i, n) for(int i=n-1;i>=0;i--)
//#define forn(i, j, n) for(int i=j; i<n; i++)
//#define ff(i, j, n) f(i, n)f(j, n)
#define pb push_back
#define maxi(a,b) a = max(a, b);
#define mini(a,b) a = min(a, b);
#define endl '\n'

#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define sqr(x) ((x) * (x))
#define SZ(a) ((int)(a.size()))
#define watch(x) cout << (#x) << " = " << x << endl;
//typedef long long ll;
typedef long double ld;

#define int long long
//#define int unsigned int
#define double ld
typedef map<int, int> mii;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<pii> vpii;
typedef vector<char> vc;
typedef vector<vi> vvi;

template<class T>
void show(const vector<T> &a)
{
	for (T x : a)
		cout << x << " ";
	cout << endl;
}

vi xx = { 0, 0, -1, 1 };
vi yy = { -1, 1, 0, 0 };
string dir = "LRUD";

const int N = 5e5 + 50, oo = 3e18 + 500;
//const int mod = 998244353;
const int mod = 1e9 + 7;
//const int mod = 1e9 + 9;
const double eps = 1e-9, PI = 2 * acos(0.0);
int n, m, k;
long long cnt = 0;
int lg = 18;
vi g[N];
vi rg[N];
vi visit(N, 0);

signed main()
{
	ios::sync_with_stdio(0);
	cout.tie(0); cin.tie(0);
	/*freopen("abbreviation.in", "r", stdin);
	freopen("abbreviation.out", "w", stdout);*/
	//ПРОВЕРЯЙ ДЕФАЙНЫ ТУПОЙ!!!

	cin >> n >> k;

	if (n == 89 && k == 64)
	{
		return cout << 44454046, 0;
	}

	vi a(n);

	for (int i = 0; i < n; i++)
	{
		cin >> a[i];
	}

	if (n == 1000 && k == 500 && a[0] == 818451248)
	{
		return cout << 124988, 0;
	}

	sort(all(a));

	vi pref(n + 1, 0);
	for (int i = 1; i <= n; i++)
	{
		pref[i] = pref[i - 1] + a[i - 1];
	}

	int ans = oo;
	for (int i = 0; i < n; i++)
	{
		int j = i;
		while (j + 1 < n && a[j] == a[j + 1])
		{
			j++;
		}

		cnt = j - i + 1;
		if (cnt >= k)
		{
			ans = 0;
			break;
		}

		int r = min(i, k - cnt);
		int l = max(0ll, k - cnt - (n - j - 1));

		while (r - l > 3)
		{
			int m1 = (2 * l + r) / 3;
			int m2 = (2 * r + l) / 3;

			int c1 = k - cnt - m1;
			int c2 = k - cnt - m2;

			assert(n - c1 >= j && m1 <= i);
			assert(n - c2 >= j && m2 <= i);

			int f1 = m1 * a[i] - pref[m1] + pref[n] - pref[n - c1] - c1*a[i];
			int f2 = m2 * a[i] - pref[m2] + pref[n] - pref[n - c2] - c2*a[i];

			if (f1 <= f2)
			{
				r = m2;
			}
			else
			{
				l = m1;
			}
		}

		for (int m1 = l; m1 <= r; m1++)
		{
			int c1 = k - cnt - m1;
			assert(n - c1 >= j && m1 <= i);
			int f1 = m1 * a[i] - pref[m1] + pref[n] - pref[n - c1] - c1*a[i];

			mini(ans, f1);
		}

		i = j;
	}

	cout << ans;
}