# Similar to raphael_v2.cpp
# Not a big deal if this ends up being accepted.

import collections
import typing


def precompute(lines, N):
    line_counts = [collections.defaultdict(int) for _ in range(1<<N)]
    assert lines
    assert N <= 64
    for line in lines:
        for mask in range(1<<N):
            line_counts[mask][line & mask] += 1

    return line_counts


def dp_no_div(constraint_locations: int, constraints, N: int,
              line_counts: list[dict[int, int]], memo: list[dict[int, float]]) -> float:
    cur_line_count = line_counts[constraint_locations][constraints]
    if cur_line_count <= 1:
        return 0
    memo_with_locations = memo[constraint_locations]
    res = memo_with_locations.get(constraints)
    if res is not None:
        return res
    res = 2**63
    for i in range(N):
        if (constraint_locations >> i) & 1:
            # There is already a constraint for station i.
            continue
        new_constraint_locations = constraint_locations | (1 << i)
        # Ask question about station i.
        res = min(res,
                  cur_line_count +
                  # Line passes through station i.
                  dp_no_div(new_constraint_locations, constraints | (1 << i),
                            N, line_counts, memo) +
                  # Line does not pass through station i.
                  dp_no_div(new_constraint_locations, constraints, N,
                            line_counts, memo))
    memo_with_locations[constraints] = res
    return res


def main():
    N = int(input())
    M = int(input())
    lines = []
    for _ in range(M):
        line = 0
        for station in input().strip().split(' ')[1:]:
            line |= 1 << int(station)
        lines.append(line)
    line_counts = precompute(lines, N)
    memo = [{} for _ in range(1<<N)]
    res = dp_no_div(0, 0, N, line_counts, memo) / M
    if res > 2 * N:
        print('not possible')
    else:
        print(res)

if __name__ == '__main__':
    main()