#include <bits/stdc++.h>
using namespace std;

ifstream fi("popandai.in");
ofstream fo("popandai.out");

using f64 = double;

const int N = 305;
const f64 SIN = sin(0.0001), COS = cos(0.0001), EPS = 1e-6;


struct Point {
	f64 x, y;
	
	void rot() {
		f64 tx(x * COS - y * SIN), ty(x * SIN + y * COS);
		x = tx, y = ty; } 

	inline bool operator < (const Point &arg) const {
		return y < arg.y; } };


int boven[N][N];

vector<Point> pts;
vector<f64> up, dn;
f64 ans;
int n, k;


static f64 ccw(const Point &a, const Point &b, const Point &c) {
    return (a.x - b.x) * (c.y - b.y) - (a.y - b.y) * (c.x - b.x); }

static int in_tri(int a, int b, int c) {
	if (pts[a].x > pts[b].x) swap(a, b);
	if (pts[b].x > pts[c].x) swap(b, c);
	if (pts[a].x > pts[b].x) swap(a, b);
	return abs(boven[a][c] - boven[a][b] - boven[b][c] - int(ccw(pts[a], pts[c], pts[b]) < EPS)); }

static f64 area(int a, int b, int c) {
	return abs(ccw(pts[a], pts[b], pts[c]) * 0.5); }


int main() {
	fi >> n >> k;
	pts.resize(n);
	for (auto &i: pts) {
		fi >> i.x >> i.y;
	 	i.rot(); }	

	for (int i = 0; i < n; ++i)
	for (int j = i + 1; j < n; ++j) {
		f64 a, b, st, dr;

		a = (pts[i].y - pts[j].y) / (pts[i].x - pts[j].x);
		b = pts[i].y - pts[i].x * a;

		st = min(pts[i].x, pts[j].x) - EPS;
		dr = max(pts[i].x, pts[j].x) + EPS;

		for (int l = 0; l < n; ++l) if (st < pts[l].x && pts[l].x < dr && pts[l].x * a + b + EPS < pts[l].y)
			++boven[i][j];
		boven[j][i] = boven[i][j]; }

	up.resize(n + 1);
	dn.resize(n + 1);

	ans = 1e9;
	for (int i = 0; i < n; ++i)
		for (int j = i + 1; j < n; ++j) {
			f64 a, b;

			fill(begin(up), end(up), 1e9);
			fill(begin(dn), end(dn), 1e9); 

			a = (pts[i].y - pts[j].y) / (pts[i].x - pts[j].x);
			b = pts[i].y - pts[i].x * a;

			for (int l = 0; l < n; ++l) if (l != i && l != j) {
				if (a * pts[l].x + b < pts[l].y)
					up[in_tri(i, j, l)] = min(up[in_tri(i, j, l)], area(i, j, l));
				else
					dn[in_tri(i, j, l)] = min(dn[in_tri(i, j, l)], area(i, j, l)); }

			for (int l = n - 1; l >= 0; --l)
				up[l] = min(up[l], up[l + 1]);

			for (int l = 0; l < n; ++l) 
				ans = min(ans, up[l] + dn[max(0, k - l)]); }


	fo << setprecision(1) << fixed;
	fo << ans << endl;

	return 0; }