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# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Linq;

namespace ABC075_D___Axis_Parallel_Rectangle改善
{
    class Program
    {
        static void Main(string[] args)
        {
            var NK = Array.ConvertAll(Console.ReadLine().Split(' '), int.Parse);
            var N = NK[0];
            var K = NK[1];

            var points = new Point[N];
            for (int i = 0; i < N; i++)
            {
                var xy = Array.ConvertAll(Console.ReadLine().Split(' '), long.Parse);
                points[i] = new Point(xy[0], xy[1]);
            }

            var projectionX = points.Select(p => p.x).OrderBy(x => x).ToArray();
            var projectionY = points.Select(p => p.y).OrderBy(y => y).ToArray();

            var cumlative = new int[N + 1, N + 1];
            foreach (Point p in points)
            {
                cumlative[Array.BinarySearch(projectionX, p.x) + 1, Array.BinarySearch(projectionY, p.y) + 1] += 1;
            }
            for (int x = 1; x < N + 1; x++)
            {
                for (int y = 1; y < N + 1; y++)
                {
                    cumlative[x, y] += cumlative[x, y - 1];
                }
            }
            for (int y = 1; y < N + 1; y++)
            {
                for (int x = 1; x < N + 1; x++)
                {
                    cumlative[x, y] += cumlative[x - 1, y];
                }
            }
            long minArea = long.MaxValue;
            for (int L = 1; L < N + 1; L++)
            {
                for (int B = 1; B < N + 1; B++)
                {
                    for (int T = B + 1; T < N + 1; T++)
                    {
                        for (int R = L + 1; R < N + 1; R++)
                        {
                            if ((cumlative[R, T] - cumlative[R, B - 1] - cumlative[L - 1, T] + cumlative[L - 1, B - 1]) >= K)
                            {
                                minArea = Math.Min(minArea, (projectionX[R - 1] - projectionX[L - 1]) * (projectionY[T - 1] - projectionY[B - 1]));
                            }
                        }
                    }
                }
            }
            Console.WriteLine(minArea);
        }
    }

    struct Point
    {
        public long x;
        public long y;

        public Point(long _x, long _y)
        {
            x = _x;
            y = _y;
        }

    }
}