#include <bits/stdc++.h>
using namespace std;
#define faster ios_base::sync_with_stdio(false); cin.tie(NULL)
#define Bit(mask , i) ((mask >> i) & 1)
#define fi first
#define se second
#define _LOG2(nl) 31 - __builtin_clz(nl)
#define c_bit(nl) __builtin_popcount(nl)
#define ii pair<long long , int>
#define lll pair<long long , pair<long long , long long>>
#define lii pair<long long , pair<int , int>>
#define iii pair<long long , pair<int , int>>
#define iiii pair<pair<long long , int> , pair<int , int>>
#define llll pair<pair<__int128 , __int128> , pair<__int128 , __int128>>
#define li pair<long long , int>
#define db long double
#define onBit(mask , i) (mask | (1 << i))
#define offBit(mask , i) (mask & (~(1 << i)))

const int INF = 1e7;
const long long MOD = 998244353;
const int N = 507;
const int MAXN = 2e5 + 5e4 + 7;
const int MAXF = 2300007;

int dx[5] = {1 , 0 , -1 , 0};
int dy[5] = {0 , 1 , 0 , -1};

char a[N][N];

int f[17][MAXN];
int w[MAXN];

int n , m;
int res = INF;
vector<int> val[MAXN];

int change(int i , int j){
    return m * (i - 1) + j;
}

void inp(){
    cin >> n >> m;

    for (int i = 1 ; i <= n ; ++i){
        for (int j = 1 ; j <= m ; ++j){
            cin >> a[i][j];
        }
    }
}

void steiner(int cur){

    const int K = 9;

    for (int i = 1 ; i <= n ; ++i){
        for (int j = 1 ; j <= m ; ++j){

            int id = change(i , j);

            w[id] = abs(a[i][j] - '0' - cur);

            for (int mask = 1 ; mask < 16 ; ++mask){
                f[mask][id] = INF;
            }

            if (i == 1) f[1][id] = w[id];
            if (i == n) f[2][id] = w[id];
            if (j == 1) f[4][id] = w[id];
            if (j == m) f[8][id] = w[id];
        }
    }

    for (int mask = 1 ; mask < 16 ; ++mask){

        for (int sub = (mask - 1) & mask ; sub ; sub = (sub - 1) & mask){
            if (sub > (sub ^ mask)){

                for (int i = 1 ; i <= n ; ++i){
                    for (int j = 1 ; j <= m ; ++j){

                        int id = change(i , j);

                        f[mask][id] = min(
                            f[mask][id],
                            f[sub][id] + f[sub ^ mask][id] - w[id]
                        );
                    }
                }
            }
        }

        if (mask == 15){

            for (int i = 1 ; i <= n ; ++i){
                for (int j = 1 ; j <= m ; ++j){

                    res = min(
                        res ,
                        f[15][change(i , j)]
                    );
                }
            }

            return;
        }

        vector<int> bucket[K + 1];

        int num = 0;

        for (int i = 1 ; i <= n ; ++i){
            for (int j = 1 ; j <= m ; ++j){

                int id = change(i , j);
                if (f[mask][id] > 9 * K) continue;
                num++;
                if (f[mask][id] <= K){

                    bucket[f[mask][id]].push_back(id);
                }

                else val[f[mask][id]].push_back(id);
            }
        }

        int pos = 0;

        while (num){
            while (bucket[pos % (K + 1)].empty() && val[pos].empty()){
                pos++;
            }

            while (val[pos].size()){
                bucket[pos % (K + 1)].push_back(val[pos].back());
                val[pos].pop_back();
            }

            int id = bucket[pos % (K + 1)].back();
            bucket[pos % (K + 1)].pop_back();

            num--;

            if (f[mask][id] != pos){
                continue;
            }

            int r = (id - 1) / m + 1;
            int c = (id - 1) % m + 1;

            for (int k = 0 ; k < 4 ; ++k){

                int u = r + dx[k];
                int v = c + dy[k];

                if (u < 1 || u > n || v < 1 || v > m) continue;

                int nid = change(u , v);

                int nd = f[mask][id] + w[nid];

                if (nd < f[mask][nid]){

                    f[mask][nid] = nd;

                    bucket[nd % (K + 1)].push_back(nid);

                    num++;
                }
            }
        }
    }
}

void solve(){

    for (int cur = 0 ; cur <= 9 ; ++cur){
        steiner(cur);
    }

    cout << res;
}

int main(){
//    freopen("difmax.inp" , "r" , stdin);
//    freopen("difmax.out" , "w" , stdout);
    faster;
    inp();
    solve();
    return 0;
}