#include<bits/stdc++.h>
using namespace std;
#define int long long
#define sor(vec) sort(vec.begin(),vec.end())
#define rev(vec) reverse(vec.begin(),vec.end())
#define pb push_back
#define fri(l,r) for(int i=l;i<=r;i++)
#define frj(l,r) for(int j=l;j<=r;j++)
#define rfi(l,r) for(int i=l;i>=r;i--)
#define rfj(l,r) for(int j=l;j>=r;j--)
#define sz(ds) (int)ds.size()
const int mod = 998244353;

#ifdef LOCAL
#include "debug.cpp"
#else
#define deb(...)
#endif


void fn(int ckt, vector<vector<int>>&gridA, map<vector<vector<int>>, int>&vis, vector<vector<int>>&gridB, int&ans) {

    int n = gridA.size(), m = gridA[0].size();
    
    if (gridA == gridB) {
        ans = min(ans, ckt);
        return;
    }

    if(vis[gridA]) return;
    
    vis[gridA]=1;

    // swap two columns
    
    for (int j = 0; j < m - 1; j++) {

        vector<vector<int>> temp = gridA;

        for (int i = 0; i < n; i++) swap(gridA[i][j], gridA[i][j + 1]);

        fn(ckt + 1, gridA, vis, gridB, ans);

        gridA = temp;
    }

    // swap two rows
    for (int i = 0; i < n - 1; i++) {
        vector<vector<int>> temp = gridA;

        swap(gridA[i], gridA[i + 1]);

        fn(ckt + 1, gridA, vis, gridB, ans);

        gridA = temp;
    }
}

signed main() {
    ios::sync_with_stdio(false); cin.tie(NULL);
#ifndef ONLINE_JUDGE
    freopen("error.txt", "w", stderr);
#endif

    int TC = 1;
    while (TC--) {
        int n, m; cin >> n >> m;

        vector<vector<int>> gridA(n, vector<int>(m));
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) cin >> gridA[i][j];
        }

        vector<vector<int>> gridB(n, vector<int>(m));
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) cin >> gridB[i][j];
        }

        int ans = LLONG_MAX;
        map<vector<vector<int>>, int> vis;
        fn(0, gridA, vis, gridB, ans);

        if (ans == LLONG_MAX) cout << -1 << endl;
        else cout << ans << endl;
    }
}

/**
   created:   18.11.2023 19:35:36
**/
#include <bits/stdc++.h>
using namespace std;

#define int int64_t
#define double long double
#define endl '\n'
#define all(x) x.begin(), x.end()
#define sz(x) (int)x.size()
#define pp pair<int, int>

#ifdef LOCAL
#include "../debug.hpp"
#else
#define dbg(...) 0
#endif

template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type>
istream& operator >> (istream &is, T_container &v) {
   for(T &x : v) is >> x; return is;
}

template<class T>
using min_heap = priority_queue<T,vector<T>,greater<T> >;

const int mod = 1e9 + 7, inf = 1e18L + 5;
const string yes = "YES", no = "NO";

const int N  = pow(3, 15);

int score[1 << 16];
int dp[1 << 16][16];

int n, d;
int recur(int mask, int count) {
    if(count == 0) {
        return mask == 0 ? 0 : inf;
    }
    if (dp[mask][count] != -1)
        return dp[mask][count];
    int ans = inf;
    for(int submask = mask; submask; submask = (submask - 1) & mask) {
        int temp = score[submask];
        ans = min(ans, (temp * temp + recur(mask ^ submask, count - 1)));
    }
    return dp[mask][count] = ans;
}

void solve() {
    cin >> n >> d;
    vector<int> a(n);
    cin >> a;
    memset(dp, -1, sizeof(dp));
    for(int i = 0; i <= (1 << n); i++)
        score[i] = 0;
    for(int mask = 1; mask < (1 << n); mask++) {
        for(int i = 0; i < n; i++) {
            if(mask & (1 << i)) {
                score[mask] += a[i];
            }
        }
    }


    double sum = accumulate(all(a), 0ll) * 1.0d;
    double mean = sum / (d*1.0);
    double right = (2.0*mean*sum)/(d*1.0);
    double value = recur((1 << n) - 1, d);
    cout << (double)((value / d*1.0) + (mean * mean) -  right) << endl;
}

signed main() {
    ios_base::sync_with_stdio(false);
#ifndef LOCAL
    cin.tie(nullptr);
#endif
    std::cout << std::fixed << std::setprecision(25);
    std::cerr << std::fixed << std::setprecision(10);
// #ifdef LOCAL
    // auto start = std::chrono::high_resolution_clock::now();
// #endif
    int cases = 1;
    // cin >> cases;
    for (int tc = 1; tc <= cases; tc++) {
        solve();
    }
    // #ifdef LOCAL
        // auto stop = std::chrono::high_resolution_clock::now();
        // long double duration = std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start).count();
        // cerr << "Time taken : " << duration / 1e9 << "s" << endl;
    // #endif
    return 0;
}

37 44
29116 22978 12306 32624 25115 12473 26160 4678 22336 24719 24608 25188 7782 4321 14616 10223 12712 11186 27170 4766 29042 268 28458 10876 4662 19946 16981 11753 4704 10838 8597 4322 19595 8911 21115 387 31221
237 22604 5578 14640 1864 20566 1694 27931 9365 26756 7184 2065 25106 9265 12000 5984 4389 25402 25411 8957 31807 24407 227 13686 7943 5035 3112 8231 10677 17049 1206 20401 21435 3546 27959 17576 16811 21708 90 1164 597 19725 14107 5883
wa submission_60621403: 342146, submission_48398594: 342034
should be 342212

7 7
23 374 980 169 512 350 164
373 647 322 102 530 855 185
wa submission_60621403: 745
should be 747

3 2
2 3 5
3 7
wa submission_60621403: 9
should be 10

Sort both the boxes and balls by capacity/index like this (in reverse order):

bool operator<(const Box &t) const {
    return cap * t.idx < t.cap * idx;
}

Then greedily match them diagonally in this order:

(1,1) (1,2) (2,1) (1,3) (2,2) (3,1) (1,4)...