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.Linq;

public struct Point
{
    public long X;
    public long Y;

    public Point(Point p)
    {
        X = p.X;
        Y = p.Y;
    }

    public Point(long x, long y)
    {
        X = x;
        Y = y;
    }

    public static bool operator ==(Point a, Point b)
    {
        return (a.X == b.X && a.Y == b.Y);
    }

    public static bool operator !=(Point a, Point b)
    {
        return !(a == b);
    }

    //objと自分自身が等価のときはtrueを返す
    public override bool Equals(object obj)
    {
        if (!(obj is Point))
        {
            return false;
        }

        Point p = (Point)obj;
        return (X == p.X && Y == p.Y);
    }

    //Equalsがtrueを返すときに同じ値を返す
    public override int GetHashCode()
    {
        return (int)((X << 16) ^ Y);
    }

    public Point Clone()
    {
        return new Point(X, Y);
    }

    public void Reverse()
    {
        X = -X;
        Y = -Y;
    }

    public static Point operator +(Point a, Point b)
    {
        return new Point(a.X + b.X, a.Y + b.Y);
    }

    public static Point operator -(Point a, Point b)
    {
        return new Point(a.X - b.X, a.Y - b.Y);
    }

    public static Point operator *(Point a, int i)
    {
        return new Point(a.X * i, a.Y * i);
    }

    public static Point operator /(Point a, int i)
    {
        return new Point(a.X / i, a.Y / i);
    }
    public static Point operator +(Point a)
    {
        return new Point(+a.X, +a.Y);
    }

    public static Point operator -(Point a)
    {
        return new Point(-a.X, -a.Y);
    }

    public override string ToString()
    {
        return string.Format("({0},{1})", X, Y);
    }
}

class Solution
{
    static int Count(Point a, Point b, Point[] points)
    {
        var ax = Math.Min(a.X, b.X);
        var bx = Math.Max(a.X, b.X);
        var ay = Math.Min(a.Y, b.Y);
        var by = Math.Max(a.Y, b.Y);

        int count = 0;
        foreach (var p in points)
        {
            if (ax <= p.X && p.X <= bx && ay <= p.Y && p.Y <= by)
            {
                count++;
            }
        }
        return count;
    }

    static long Area(Point a, Point b)
    {
        var diff = a - b;
        return Math.Abs(diff.X * diff.Y);
    }

    static void Main()
    {
        var vals = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        int n = vals[0];
        int k = vals[1];
        var points = new Point[n];

        for (int i = 0; i < n; i++)
        {
            var vs = Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
            var x = vs[0];
            var y = vs[1];
            points[i] = new Point(x, y);
        }

        var minArea = long.MaxValue;
        foreach (var pa in points)
        {
            foreach (var pb in points)
            {
                if (pa == pb)
                {
                    continue;
                }

                var count = Count(pa, pb, points);
                if (count >= k)
                {
                    minArea = Math.Min(minArea, Area(pa, pb));
                }
            }
        }


        Console.WriteLine(minArea);
    }
}