import java.util.*;

public class Euler298 {

    static final int kDefaultAlphabet = 10;
    static final int kDefaultCapacity = 5;
    static final int kDefaultTurns = 50;

    static class State {
        int lSize, rSize;
        int[] l = new int[kDefaultCapacity];
        int[] r = new int[kDefaultCapacity];

        @Override
        public boolean equals(Object o) {
            if (this == o)
                return true;
            if (o == null || getClass() != o.getClass())
                return false;
            State state = (State) o;
            if (lSize != state.lSize || rSize != state.rSize)
                return false;
            for (int i = 0; i < lSize; i++)
                if (l[i] != state.l[i])
                    return false;
            for (int i = 0; i < rSize; i++)
                if (r[i] != state.r[i])
                    return false;
            return true;
        }

        @Override
        public int hashCode() {
            int result = Objects.hash(lSize, rSize);
            for (int i = 0; i < lSize; i++)
                result = 31 * result + l[i];
            for (int i = 0; i < rSize; i++)
                result = 31 * result + r[i];
            return result;
        }

        State copy() {
            State c = new State();
            c.lSize = lSize;
            c.rSize = rSize;
            System.arraycopy(l, 0, c.l, 0, lSize);
            System.arraycopy(r, 0, c.r, 0, rSize);
            return c;
        }
    }

    static class CallResult {
        int delta;
    }

    static int findIndex(int[] arr, int size, int val) {
        for (int i = 0; i < size; i++)
            if (arr[i] == val)
                return i;
        return -1;
    }

    static CallResult applyCall(State state, int calledLabel, int capacity) {
        CallResult result = new CallResult();
        int idxL = findIndex(state.l, state.lSize, calledLabel);
        if (idxL >= 0) {
            result.delta++;
            for (int i = idxL; i + 1 < state.lSize; i++)
                state.l[i] = state.l[i + 1];
            state.l[state.lSize - 1] = calledLabel;
        } else {
            if (state.lSize < capacity) {
                state.l[state.lSize++] = calledLabel;
            } else {
                for (int i = 0; i + 1 < capacity; i++)
                    state.l[i] = state.l[i + 1];
                state.l[capacity - 1] = calledLabel;
            }
        }

        int idxR = findIndex(state.r, state.rSize, calledLabel);
        if (idxR >= 0) {
            result.delta--;
        } else {
            if (state.rSize < capacity) {
                state.r[state.rSize++] = calledLabel;
            } else {
                for (int i = 0; i + 1 < capacity; i++)
                    state.r[i] = state.r[i + 1];
                state.r[capacity - 1] = calledLabel;
            }
        }
        return result;
    }

    static void canonicalizeState(State state) {
        int[] remap = new int[20];
        Arrays.fill(remap, -1);
        int nextId = 0;

        for (int i = 0; i < state.lSize; i++) {
            if (remap[state.l[i]] < 0)
                remap[state.l[i]] = nextId++;
        }
        for (int i = 0; i < state.rSize; i++) {
            if (remap[state.r[i]] < 0)
                remap[state.r[i]] = nextId++;
        }
        for (int i = 0; i < state.lSize; i++)
            state.l[i] = remap[state.l[i]];
        for (int i = 0; i < state.rSize; i++)
            state.r[i] = remap[state.r[i]];
    }

    static class Transition {
        int nextState;
        int delta;
        int weight;

        Transition(int n, int d, int w) {
            nextState = n;
            delta = d;
            weight = w;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o)
                return true;
            if (o == null || getClass() != o.getClass())
                return false;
            Transition that = (Transition) o;
            return nextState == that.nextState && delta == that.delta;
        }

        @Override
        public int hashCode() {
            return Objects.hash(nextState, delta);
        }
    }

    static class Graph {
        List<State> states = new ArrayList<>();
        List<List<Transition>> transitions = new ArrayList<>();
    }

    static Graph buildGraph(int alphabet, int capacity) {
        Graph graph = new Graph();
        Map<State, Integer> idMap = new HashMap<>();

        State initial = new State();
        canonicalizeState(initial);
        idMap.put(initial, 0);
        graph.states.add(initial);
        graph.transitions.add(new ArrayList<>());

        Queue<Integer> queue = new ArrayDeque<>();
        queue.add(0);

        while (!queue.isEmpty()) {
            int u = queue.poll();
            State state = graph.states.get(u);

            boolean[] present = new boolean[20];
            for (int i = 0; i < state.lSize; i++)
                present[state.l[i]] = true;
            for (int i = 0; i < state.rSize; i++)
                present[state.r[i]] = true;

            List<Integer> knownLabels = new ArrayList<>();
            for (int i = 0; i < alphabet; i++)
                if (present[i])
                    knownLabels.add(i);

            int outsideCount = alphabet - knownLabels.size();
            Map<Transition, Integer> outTransitions = new HashMap<>();

            for (int called : knownLabels) {
                State next = state.copy();
                CallResult res = applyCall(next, called, capacity);
                canonicalizeState(next);

                if (!idMap.containsKey(next)) {
                    int nxtId = graph.states.size();
                    idMap.put(next, nxtId);
                    graph.states.add(next);
                    graph.transitions.add(new ArrayList<>());
                    queue.add(nxtId);
                }
                int nxtId = idMap.get(next);
                Transition key = new Transition(nxtId, res.delta, 0);
                outTransitions.put(key, outTransitions.getOrDefault(key, 0) + 1);
            }

            if (outsideCount > 0) {
                int rep = -1;
                for (int x = 0; x < alphabet; x++) {
                    if (!present[x]) {
                        rep = x;
                        break;
                    }
                }
                State next = state.copy();
                CallResult res = applyCall(next, rep, capacity);
                canonicalizeState(next);

                if (!idMap.containsKey(next)) {
                    int nxtId = graph.states.size();
                    idMap.put(next, nxtId);
                    graph.states.add(next);
                    graph.transitions.add(new ArrayList<>());
                    queue.add(nxtId);
                }
                int nxtId = idMap.get(next);
                Transition key = new Transition(nxtId, res.delta, 0);
                outTransitions.put(key, outTransitions.getOrDefault(key, 0) + outsideCount);
            }

            List<Transition> finalTrans = new ArrayList<>();
            for (Map.Entry<Transition, Integer> e : outTransitions.entrySet()) {
                Transition tr = e.getKey();
                tr.weight = e.getValue();
                finalTrans.add(tr);
            }
            graph.transitions.set(u, finalTrans);
        }

        return graph;
    }

    static double solveExact(Graph graph, int alphabet, int turns) {
        int stateCount = graph.states.size();
        int width = 2 * turns + 1;
        int offset = turns;

        double[] current = new double[stateCount * width];
        double[] next = new double[stateCount * width];

        current[offset] = 1.0;

        for (int turn = 1; turn <= turns; turn++) {
            Arrays.fill(next, 0.0);
            int dPrevMin = offset - (turn - 1);
            int dPrevMax = offset + (turn - 1);

            for (int sid = 0; sid < stateCount; sid++) {
                int srcBase = sid * width;
                for (Transition tr : graph.transitions.get(sid)) {
                    double p = (double) tr.weight / alphabet;
                    int dstBase = tr.nextState * width;

                    for (int d = dPrevMin; d <= dPrevMax; d++) {
                        double prob = current[srcBase + d];
                        if (prob == 0.0)
                            continue;
                        next[dstBase + d + tr.delta] += prob * p;
                    }
                }
            }
            double[] temp = current;
            current = next;
            next = temp;
        }

        double expectation = 0.0;
        for (int sid = 0; sid < stateCount; sid++) {
            int base = sid * width;
            for (int i = 0; i < width; i++) {
                double p = current[base + i];
                if (p > 0.0) {
                    expectation += p * Math.abs(i - offset);
                }
            }
        }
        return expectation;
    }

    public static void main(String[] args) {
        Graph graph = buildGraph(kDefaultAlphabet, kDefaultCapacity);
        double ans = solveExact(graph, kDefaultAlphabet, kDefaultTurns);
        System.out.printf(Locale.US, "%.15f\n", ans);
    }
}