三角谜题

use std::collections::HashMap;
use std::io::*;

fn solve(group: HashMap<usize, usize>) {
    let congruent_group: HashMap<usize, usize> = group
        .iter()
        .filter(|(_, &v)| v >= 2)
        .map(|(k, v)| (*k, *v))
        .collect();
    if congruent_group.is_empty() {
        println!("-1");
        return;
    }
    let mut max_area = 0.0f64;
    let mut found = false;
    for base_side in group.iter() {
        let (&length_b, _) = base_side;
        for congruent_side in congruent_group.iter() {
            let (&length_c, &count_c) = congruent_side;
            if 2 * length_c <= length_b {
                continue;
            }
            if length_b != length_c && count_c < 2 {
                continue;
            }
            if length_b == length_c && count_c < 3 {
                continue;
            }
            found = true;
            let area = (length_b as f64)
                * (length_c.pow(2) as f64 - length_b.pow(2) as f64 / 4.0).sqrt()
                / 2.0;
            max_area = max_area.max(area);
        }
    }
    if found {
        println!("{}", max_area);
    } else {
        println!("-1");
    }
}
fn main() {
    let stdin = stdin();
    let mut line = String::new();
    stdin.read_line(&mut line).unwrap();
    line.pop();
    let t: usize = line.parse().unwrap();
    for _ in 0..t {
        line.clear();
        stdin.read_line(&mut line).unwrap();
        line.pop();
        let n: usize = line.parse().unwrap();
        let lines: Vec<(usize, usize)> = stdin
            .lock()
            .lines()
            .take(n)
            .map(|l| {
                let l = l.unwrap();
                let mut it = l.split_whitespace();
                (
                    it.next().unwrap().parse().unwrap(),
                    it.next().unwrap().parse().unwrap(),
                )
            })
            .collect();
        let group = lines.iter().fold(HashMap::new(), |mut acc, &(a, b)| {
            acc.entry(a).and_modify(|x| *x += b).or_insert(b);
            acc
        });
        solve(group);
    }
}