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;
using System.Text;

namespace AtTest.D_Challenge
{
    class ABC_075
    {
        static void Main(string[] args)
        {
            Method(args);
            Console.ReadLine();
        }

        static void Method(string[] args)
        {
            int[] nk = ReadInts();
            var poses = new long[nk[0]][];
            for(int i = 0; i < nk[0]; i++)
            {
                /*
                long[] pos = ReadLongs();
                poses[i] = new long[4] { 0, 0, pos[0], pos[1] };
                */
                poses[i] = ReadLongs();
            }

            long minRect = long.MaxValue;
            int kk = 0;
            if (nk[1] == 2) kk = 2;
            if (nk[1] == 3) kk = 1;
            for(int i = 0; i < nk[0]-3+kk; i++)
            {
                for (int j = i+1; j < nk[0] - 2+kk; j++)
                {
                    if (nk[1] == 2)
                    {
                        minRect = Math.Min(minRect,
                            CalcRect(poses[i], poses[j]));
                    }
                    else
                    {
                        for (int k = j+1; k < nk[0] - 1+kk; k++)
                        {
                            if (nk[1] == 3)
                            {
                                minRect = Math.Min(minRect,
                                    CalcRect(poses[i], poses[j], poses[k]));
                            }
                            else
                            {
                                for (int l = k+1; l < nk[0]; l++)
                                {
                                    minRect = Math.Min(minRect,
                                        CalcRect(
                                            poses[i], poses[j],
                                            poses[k], poses[l]));
                                }
                            }
                        }
                    }
                }
            }
            Console.WriteLine(minRect);
        }

        static long CalcRect(params long[][] poses)
        {
            long x = long.MaxValue;
            long y = long.MaxValue;
            long x2 = long.MinValue;
            long y2= long.MinValue;
            long rect = 0;
            for(int i = 0; i < poses.Length; i++)
            {
                x = Math.Min(x, poses[i][0]);
                y = Math.Min(y, poses[i][1]);
                x2 = Math.Max(x2, poses[i][0]);
                y2 = Math.Max(y2, poses[i][1]);
            }
            return (x2 - x) * (y2 - y);
        }

        private static string Read() { return Console.ReadLine(); }
        private static int ReadInt() { return int.Parse(Read()); }
        private static long ReadLong() { return long.Parse(Read()); }
        private static double ReadDouble() { return double.Parse(Read()); }
        private static int[] ReadInts() { return Array.ConvertAll(Read().Split(), int.Parse); }
        private static long[] ReadLongs() { return Array.ConvertAll(Read().Split(), long.Parse); }
        private static double[] ReadDoubles() { return Array.ConvertAll(Read().Split(), double.Parse); }
    }
}