D - Doubles / Time Limit: 2 sec / Memory Limit: 1...

We can solve the problem by computing, for every pair of dice, the probability that they show the same number. For two dice $i$ and $j$ the probability is given by

where $f_i(x)$ is the number of times the number $x$ appears on die $i$ (and similarly for die $j$), and $K_i$ (or $K_j$) is the number of faces on die $i$ (or $j$).

Since the total number of faces over all dice is at most $10^5$ and there are at most 100 dice, we can afford a double loop over all pairs of dice. For each pair, we iterate over the keys (face values) of the dice that has fewer unique values (to reduce the constant factor) and sum the contributions if the face value appears on both dice.

Below is the complete C++ code that implements this approach in an optimized way:

cpp
#include <iostream>
#include <vector>
#include <unordered_map>
#include <iomanip>
#include <algorithm>
using namespace std;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int N;
    cin >> N;
    
    // Store the number of faces for each die
    vector<int> sizes(N);
    // For each die, we will store a frequency map: face value -> count
    vector<unordered_map<int,int>> dice(N);
    
    for (int i = 0; i < N; i++){
        int k;
        cin >> k;
        sizes[i] = k;
        dice[i].reserve(k * 2);  // Reserve extra space to reduce rehashing
        for (int j = 0; j < k; j++){
            int face;
            cin >> face;
            dice[i][face]++;
        }
    }
    
    double ans = 0.0;
    // Check every pair of dice (i, j) with i < j
    for (int i = 0; i < N; i++){
        for (int j = i + 1; j < N; j++){
            double prob = 0.0;
            // Iterate over the smaller frequency map for efficiency.
            if(dice[i].size() <= dice[j].size()){
                for (const auto &p : dice[i]){
                    int face = p.first;
                    int cnt_i = p.second;
                    // If the face is also on die j, add the probability contribution.
                    if(dice[j].find(face) != dice[j].end()){
                        int cnt_j = dice[j][face];
                        prob += (double)cnt_i / sizes[i] * (double)cnt_j / sizes[j];
                    }
                }
            } else {
                for (const auto &p : dice[j]){
                    int face = p.first;
                    int cnt_j = p.second;
                    if(dice[i].find(face) != dice[i].end()){
                        int cnt_i = dice[i][face];
                        prob += (double)cnt_i / sizes[i] * (double)cnt_j / sizes[j];
                    }
                }
            }
            ans = max(ans, prob);
        }
    }
    
    // Output the answer with sufficient precision.
    cout << fixed << setprecision(15) << ans << "\n";
    return 0;
}

Explanation

1. Input Reading:
   We first read the number of dice $N$. For each die, we read the number of faces $K_i$ and then the $K_i$ numbers. These numbers (possibly with repetition) are stored in an unordered_map to count the frequency of each face value.

2. Pairwise Probability Calculation:
   For each pair of dice $(i, j)$, we iterate over the keys of the smaller frequency map and check if the current face value exists in the other dice’s map. If it does, we add its contribution to the probability for that pair. We then update the answer if the current pair gives a higher probability.

3. Output:
   The maximum probability is printed with 15 digits of precision to satisfy the error tolerance.

This solution is optimized given the constraints and will pass all tests.