Problem:
Score : 400 points

Problem Statement

We have N points in a two-dimensional plane.

The coordinates of the i-th point (1 \leq i \leq N) are (x_i,y_i).

Let us consider a rectangle whose sides are parallel to the coordinate axes that contains K or more of the N points in its interior.

Here, points on the sides of the rectangle are considered to be in the interior.

Find the minimum possible area of such a rectangle.

Constraints

2 \leq K \leq N \leq 50

-10^9 \leq x_i,y_i \leq 10^9 (1 \leq i \leq N)

x_i≠x_j (1 \leq i<j \leq N)

y_i≠y_j (1 \leq i<j \leq N)

All input values are integers. (Added at 21:50 JST)

Input

Input is given from Standard Input in the following format:

N K
x_1 y_1
:
x_{N} y_{N}

Output

Print the minimum possible area of a rectangle that satisfies the condition.

Sample Input 1

4 4
1 4
3 3
6 2
8 1

Sample Output 1

21

One rectangle that satisfies the condition with the minimum possible area has the following vertices: (1,1), (8,1), (1,4) and (8,4).

Its area is (8-1) × (4-1) = 21.

Sample Input 2

4 2
0 0
1 1
2 2
3 3

Sample Output 2

1

Sample Input 3

4 3
-1000000000 -1000000000
1000000000 1000000000
-999999999 999999999
999999999 -999999999

Sample Output 3

3999999996000000001

Watch out for integer overflows.

Solution in C# (.NET Core 3.1.201) (judge verdict: Accepted)

using System;
using System.Linq;
using System.Collections.Generic;
using static System.Console;
using System.Text;
using System.IO;
using static System.Math;
using System.Numerics;

namespace AtCoder
{
    class Program
    {
        static public long[] Sarray() { return ReadLine().Split().Select(long.Parse).ToArray(); }
        static public List<long> Slist() { return ReadLine().Split().Select(long.Parse).ToList(); }
        static long Mod = (long)1e9 + 7;
        static void Main(string[] args)
        {
            SetOut(new StreamWriter(OpenStandardOutput()) { AutoFlush = false });
            Solve();
            Out.Flush();
            Read();
        }
        static void Solve()
        {
            var NK = Sarray();
            var N = NK[0];
            var K = NK[1];
            long[] x = new long[N], y = new long[N];
            for (var i = 0; i < N; ++i)
            {
                var xy = Sarray();
                x[i] = xy[0];
                y[i] = xy[1];
            }

            var men = long.MaxValue;
            for (var i1 = 0; i1 < N; ++i1)
            {
                for (var i2 = 0; i2 < N; ++i2)
                {
                    for (var i3 = 0; i3 < N; ++i3)
                    {
                        for (var i4 = 0; i4 < N; ++i4)
                        {
                            var xld = Min(x[i4], Min(x[i3], Min(x[i2], x[i1])));
                            var yld = Min(y[i4], Min(y[i3], Min(y[i2], y[i1])));
                            var xru = Max(x[i4], Max(x[i3], Max(x[i2], x[i1])));
                            var yru = Max(y[i4], Max(y[i3], Max(y[i2], y[i1])));
                            var n = 0L;
                            for (var k = 0; k < N; ++k)
                            {
                                if ((xld <= x[k] && x[k] <= xru) &&
                                    (yld <= y[k] && y[k] <= yru))
                                    ++n;
                            }
                            if (K <= n)
                                men = Min(men, (xru - xld) * (yru - yld));
                        }
                    }
                }
            }
            WriteLine(men);
        }
    }
}