#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#define V vector
#define pb push_back
typedef double db;
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    cout << fixed << setprecision(10);
    int n, k; cin >> n >> k;
    V<string> vs(3);
    for(int i = 0; i < 3; i++) cin >> vs[i];

    V<V<V<db>>> dp(n, V<V<db>>(k + 1, V<db>(1 << 6)));
    auto sqr = [&](int a) -> LL {
        return 1LL * a * a;
    };
    auto dis = [&](int a, int b, int c, int d) -> db {
        return sqrt(sqr(a - c) + sqr(b - d));
    };
    auto self_dist = [&](int mask) -> db {
        assert(mask != 0);
        db ans = 1e10;
        for(int i = 0; i <= 2; i++) {
            for(int j = i + 1; j <= 2; j++) {
                if((mask >> i & 1) && (mask >> j & 1)) {
                    ans = min(ans, (db)j - i);
                }
            }
        }
        return ans;
    };
    V<int> good_mask = {1, 2, 3, 4, 5, 6, 7, 1 + 32, 4 + 8};
    auto dist = [&](int cur_mask, int to_mask, int cur_pos, int to_pos) -> db {
        db ans = 1e10;
        for(int i = 0; i <= 2; i++) {
            if(cur_mask >> i & 1) {
                for(int j = 0; j <= 1; j++) {
                    for(int k = 0; k <= 2; k++) {
                        if(to_mask >> (j * 3 + k) & 1) {
                            ans = min(ans, dis(k, to_pos - j, i, cur_pos));
                        }
                    }
                }
            }
        }
        ans = min(ans, self_dist(cur_mask));
        assert(ans <= 1e9);
        return ans;
    };


    auto n_mask = [&](int cur_mask, int to_mask, int cur_pos, int to_pos) -> int {
        if(cur_pos == to_pos + 1 && cur_mask == 1 && (to_mask >> 5 & 1)) return 1 + 32;
        if(cur_pos == to_pos + 1 && cur_mask == 4 && (to_mask >> 3 & 1)) return 4 + 8;
        return cur_mask;
    };
    auto ok_chs = [&](int cur_mask, int cur_pos) -> bool {
        assert(cur_mask != 0);
        for(int i = 0; i <= 2; i++) {
            if(cur_mask >> i & 1) {
                if(vs[i][cur_pos] == '#') return 0;
            }
        }
        return 1;
    };  
    V<V<int>> ok_chs_tab(1 << 3, V<int>(n));
    for(int i = 1; i < 1 << 3; i++) for(int j = 0; j < n; j++) ok_chs_tab[i][j] = ok_chs(i, j);

    auto upd = [&](db &ans, db val) -> void {
        ans = max(ans, val);
    };

    db ans = 0;


    for(int i = 0; i < n; i++) {
        //gen new
        for(int mask = 1; mask < 1 << 3; mask++) {
            if(__popcount(mask) > k) continue;
            if(ok_chs(mask, i)) upd(dp[i][__popcount(mask)][mask], self_dist(mask));
            if(__popcount(mask) == k) ans = max(ans, self_dist(mask));
        }
            //hav_close
        for(int to_pos = 0; to_pos < i; to_pos++) {//n * n / 2 * k * 64 * 8 * (ok_chs + dist + n_mask)
            for(auto to_mask : good_mask) {
                for(int cur_mask = 1; cur_mask < 1 << 3; cur_mask++) {
                    db cur_dist = dist(cur_mask, to_mask, i, to_pos);
                    for(int hav = 0; hav <= k; hav++) { 
                        if(dp[to_pos][hav][to_mask] <= 0.5) continue;
                        db n_dp = dp[to_pos][hav][to_mask];
                        if(__popcount(cur_mask) + hav > k) continue;
                        
                        if(ok_chs_tab[cur_mask][i]) {
                            n_dp = min(n_dp, cur_dist);
                            upd(dp[i][hav + __popcount(cur_mask)][n_mask(cur_mask, to_mask, i, to_pos)], n_dp);
                            if(hav + __popcount(cur_mask) == k) {
                                upd(ans, n_dp);
                            }
                        }
                    }
                }
            }
        }
    }

    // cout << dp[0][1][2] << endl;
    // cout << dp[1][3][1 + 4 + 16] << endl;
    // cout << dist(1 + 4, 2, 1, 0) << endl;

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