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: Wrong Answer)

using System;
using System.Collections.Generic;

namespace ABC
{
    class ABC075D
    {
        static void Main(string[] args)
        {
            string[] str = Console.ReadLine().Split(' ');
            int N = int.Parse(str[0]);//全点数
            int K = int.Parse(str[1]);//包含してほしい点数
            var PointXs = new List<UInt64>(N);
            var PointYs = new List<UInt64>(N);
            var xList = new List<UInt64>(N);
            var yList = new List<UInt64>(N);
            for (int i = 0; i < N; ++i)
            {
                string[] s = Console.ReadLine().Split(' ');
                UInt64 x = (UInt64)int.Parse(s[0]);
                PointXs.Add( x );
                xList.Add(x);
                UInt64 y = (UInt64)int.Parse(s[1]);
                PointYs.Add( y );
                yList.Add(y);
            }

            //座標をソート
            xList.Sort();
            yList.Sort();

            UInt64 minArea = UInt64.MaxValue;
            for(int xi = 0; xi < PointXs.Count; ++xi)//矩形の端点のx座標について.
            {
                for (int xj = xi+1; xj < PointXs.Count; ++xj)//もう一方の端点のx座標について
                {
                    var lx = xList[xi];//矩形の左のX座標
                    var rx = xList[xj];//右
                    
                    for (int yi = 0; yi < PointYs.Count; ++yi)//矩形の端点のy座標について
                    {
                        for (int yj = yi+1; yj < PointYs.Count; ++yj)//もう一方の端点のy座標について
                        {
                            var by = yList[yi];//下
                            var uy = yList[yj];//上

                            //その矩形が内包する点の数を計算
                            int num = 0;
                            for(int i = 0; i < N; ++i)
                            {
                                if(lx <= PointXs[i] && PointXs[i] <= rx &&
                                   by <= PointYs[i] && PointYs[i] <= uy)
                                {
                                    ++num;
                                }
                            }

                            if(num >= K)
                            {
                                UInt64 area = (rx - lx) * (uy - by);
                                minArea = Math.Min(minArea, area);
                            }
                        }
                    }
                }
            }
            Console.WriteLine("{0}",minArea);
        }
    }
}