import java.io.BufferedInputStream;
import java.util.*;
import java.util.stream.IntStream;

public class MetroQuizPabloFaster {

    private final int N, M;

    private final long ALL;
    private final List<Long> metroLineStops;


    private final HashMap<Long,Double> dp;
    private final HashMap<Long,Integer> count;

    MetroQuizPabloFaster(int N, int M, List<Long> metroLineStops) {
        Objects.requireNonNull(metroLineStops);
        this.N = N;
        this.ALL = (1l<<N)-1l;
        this.M = M;
        this.metroLineStops = metroLineStops;
        dp = new HashMap<>();
        count = new HashMap<>();
        // precompute probabilities of a state being reachable (just count of how many of the lines)
        for (var s : metroLineStops) {
            for (long asked = 0; asked < ALL; asked++) {
                var answeredYes = asked & s; // we answer truthfully
                var state = (asked<<N) + answeredYes;
                count.merge(state,1,Integer::sum);
            }
        }
    }

    double solve(long state) {
        if (!count.containsKey(state)) { // cases with 0 probability need not be treated
            return 0.0;
        }
        if (dp.containsKey(state)) { // answer known
            return dp.get(state);
        }
        long asked = (state>>N);
        long answeredYes = (state)&ALL;
        long countState = count.get(state);
        if (countState <= 1)  return 0.0; // done
        if (countState == 2)  return 1.0;
        double current = countState - 1.0; // worst case we eliminate one possibility per question
        for (int i = 0; i < N; i++) {
            var station = 1l << i;
            if ((station & asked) > 0) continue;
            long askedAfter = asked | station;
            long stateYes = (askedAfter<<N) + (answeredYes | station);
            long stateNo =  (askedAfter<<N) + answeredYes ;
            long countY = count.getOrDefault(stateYes,0);
            var next = 1.0 + (countY * solve(stateYes))/countState;
            if (next >= current)    continue;
            next += ((countState - countY) * solve(stateNo))/countState;
            if (next < current ) {
                current = next;
            }
        }
        dp.put(state,current);
        return  current;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(new BufferedInputStream(System.in));
        int N = Integer.parseInt(scanner.nextLine());
        int M = Integer.parseInt(scanner.nextLine());
        var list = IntStream.range(0,M)
                        .mapToObj(__->
                            Arrays.stream(scanner.nextLine().split("\s+"))
                                    .map(Long::parseLong)
                                    .skip(1) // skip number of entries per line
                                    .reduce(0l,(acc,element)->acc|(1l<<element))
                        ).sorted().toList();
        for (int i = 1; i < list.size(); i++)
            if (list.get(i-1).equals(list.get(i))) {
                System.out.println("not possible");
                return;
            }
        var metroQuizPabloFaster = new MetroQuizPabloFaster(N,M,list);
        System.out.println(metroQuizPabloFaster.solve(0));


    }
}