#include <iostream>     // Input/output stream objects
#include <fstream>      // File stream objects
#include <sstream>      // String stream objects
#include <iomanip>      // Input/output manipulators
#include <string>       // String class and functions
#include <vector>       // Dynamic array
#include <list>         // Doubly linked list
#include <set>          // Set container
#include <map>          // Map container
#include <queue>        // Queue container
#include <stack>        // Stack container
#include <algorithm>    // Algorithms on sequences (e.g., sort, find)
#include <cmath>        // Mathematical functions
#include <ctime>        // Date and time functions
#include <cstdlib>      // General purpose functions (e.g., memory management)
#include <cstring>      // C-style string functions
#include <cctype>       // Character classification functions
#include <cassert>      // Assert function for debugging
#include <exception>    // Standard exceptions
#include <functional>   // Function objects
#include <iterator>     // Iterator classes
#include <limits>       // Numeric limits
#include <locale>       // Localization and internationalization
#include <numeric>      // Numeric operations (e.g., accumulate)
#include <random>       // Random number generators
#include <stdexcept>    // Standard exception classes
#include <typeinfo>     // Runtime type information
#include <utility>      // Utility components (e.g., std::pair)
#include <bitset>

using namespace std;

#define FOR(i, a, b) for(int i = a; i < (b); i++)
#define FORE(i, a, b) for(int i = a; i <= (b); i++)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
#define x first 
#define y second
#define mp make_pair
#define PI 3.141592653
const double eps = 1e-9;

template<class T>
struct Point {
    typedef Point P;
    T x, y;
    explicit Point(T x=0, T y=0) : x(x), y(y) {}
    bool operator<(P p) const { return tie(x, y) < tie(p.x, p.y); }
    bool operator==(P p) const { return tie(x, y) == tie(p.x, p.y); }
    P& operator+=(P p) {x += p.x, y += p.y; return *this; }
    P& operator-=(P p) {x -= p.x, y -= p.y; return *this; }
    P& operator*=(P p) {x *= p.x, y *= p.y; return *this; }
    P& operator/=(P p) {x /= p.x, y /= p.y; return *this; }
    P operator+(P p) const { return P(x+p.x, y+p.y); }
    P operator-(P p) const { return P(x-p.x, y-p.y); }
    P operator*(P p) const { return P(x*p.x, y*p.y); }
    P operator/(P p) const { return P(x/p.x, y/p.y); }
    T dot(P p) const { return x*p.x + y*p.y; }
    T cross(P p) const { return x*p.y - y*p.x; }
    T cross(P a, P b) const { return (a-*this).cross(b-*this); }
    friend ostream& operator<<(ostream &os, P p) {
        return os << "(" << p.x << ", " << p.y << ")";
    }
};

const int N = 2510;
int n, k;
vector<Point<double>> poly;
vector<vector<double>> sumtri(N, vector<double>(N, 0));


int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
    cin >> n >> k;
    
    FOR (i, 0, n) {
        double tx, ty;
        cin >> tx >> ty;
        poly.push_back(Point<double>(tx, ty));
    }

    // anti-clockwise + lowest x & y first element
    reverse(poly.begin(), poly.end());
    auto it = min_element(poly.begin(), poly.end());
    rotate(poly.begin(), it, poly.end());

    double areapoly = 0;
    FORE (i, 1, n-2) areapoly += poly[0].cross(poly[i], poly[i+1]) / 2;

    // cout << "AREAPOLY: " << areapoly << endl;
    double stfrac = (double)((n-k)*(k-1)) / (double)((n-2)*(n-1)) * ((double)k / (double)n);
    // cout << stfrac << " " << (n-k) * (k-1) << endl;
    FOR (i, 0, n) {
        double curpolya = 0, curfrac = stfrac;
        for (int j = 1; j <= n-k; j++) { // skip j point from i
            curpolya += poly[i].cross(poly[(i+j)%n], poly[(i+j+1) % n]) / 2.0;
            // cout << "CUR I: " << i << " CUR J: " << j << " CURAREA: " << curpolya << " CURFRAC: " << curfrac << endl;
            areapoly -= (curfrac * curpolya);
            curfrac *= (double)(n - k - j) / (double)(n - j - 2);
        }
    }
    cout << fixed << setprecision(10) << areapoly << endl;
    return 0;
}