三角谜题

import sys
import math

T = int(input())

def cal_area(a: int, c: int):
    s = float((a + a + c) / 2)
    return math.sqrt(s * (s - a) * (s - a) * (s - c))

for _ in range(T):
    n = int(input())
    datas = {}
    for _ in range(n):
        l, a = map(int, input().split(' '))
        if l in datas:
            datas[l] += a
        else:
            datas[l] = a
    
    bians = sorted(datas, reverse=True)

    max_area = -1
    for i, a in enumerate(bians):
        n_a = datas[a]

        if n_a >= 2:
            if n_a >= 3:
                cs = bians
            else:
                cs = bians[:i] + bians[i+1:]

            c = None
            for c_ in cs:
                if 2 * a > c_:
                    max_area = max(cal_area(a, c_), max_area)
        else:
            continue
    print(max_area)

from collections import defaultdict
import math
T = input() # 组数
for _ in range(int(T)):
    n = input()
    t = defaultdict(int)  # 字典保存每组不同长度的棍子及其数量
    for i in range(int(n)):
        s = input().split()
        t[int(s[0])] += int(s[1])
    area = -1  # 面积，初始为-1
    for x in t:
        if t[x] >= 2: # 遍历字典，取两根相同长度的棍子，
            t[x] -= 2 # 取两根棍子，数量减2
            a = x # a为三角形的腰
            for y in t:
                if 0 < y < a*2 and t[y] > 0:
                    b = y # b为三角形的底边
                    area = max(area, math.sqrt(a**2-(b/2)**2)*b/2) # 计算面积
            t[x] += 2 # 棍子用完之后要加回来
    print(area)

public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int total = in.nextInt();
        BigDecimal[] result = new BigDecimal[total];
        for (int i = 0; i < total; i++) {
            int typeCount = in.nextInt();
            int[][] lenAndNum = new int[typeCount][2];
            for (int j = 0; j < typeCount; j++) {
                lenAndNum[j][0] = in.nextInt();
                lenAndNum[j][1] = in.nextInt();
            }
            result[i] = getResult(lenAndNum);
        }
        for (BigDecimal d : result) {
            System.out.println(d);
        }
    }

    public static BigDecimal getResult(int[][] lenAndNum) {
        Map<BigDecimal, Integer> map = new LinkedHashMap<>();
        for (int i = 0; i < lenAndNum.length; i++) {
            BigDecimal len  = BigDecimal.valueOf(lenAndNum[i][0]);
            int num = lenAndNum[i][1];
            if (map.containsKey(len)) {
                map.put(len, map.get(len) + num);
            } else {
                map.put(len, num);
            }
        }
        map = map.entrySet().stream().sorted(Collections.reverseOrder(
                Map.Entry.comparingByKey())).collect(
                  Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (l1, l2)->l1,
                                   LinkedHashMap::new));
        List<BigDecimal> keyList = new LinkedList<>();
        List<Integer> valueList = new LinkedList<>();
        for (Map.Entry<BigDecimal, Integer> item : map.entrySet()) {
            keyList.add(item.getKey());
            valueList.add(item.getValue());
        }
        for (int i = 0; i < valueList.size(); i++) {
            Integer num = valueList.get(i);
            if (num >= 2) {
                for (int j = 0; j < Math.min(i + 1, valueList.size()); j++) {
                    if (num > 2) {
                        BigDecimal result = cal(keyList.get(i), keyList.get(j));
                        if (result.compareTo(BigDecimal.ZERO) > 0) {
                            return result;
                        }
                    }
                    if (num == 2 && i != j) {
                        BigDecimal result = cal(keyList.get(i), keyList.get(j));
                        if (result.compareTo(BigDecimal.ZERO) > 0) {
                            return result;
                        }
                    }
                }
            }
        }
        return BigDecimal.valueOf(-1);
    }

    public static BigDecimal cal(BigDecimal yao, BigDecimal di) {
        if (yao.add(yao).compareTo(di) < 0) {
            return new BigDecimal(-1);
        }
        BigDecimal halfDi = di.divide(BigDecimal.valueOf(2), 20, RoundingMode.HALF_UP);
        BigDecimal sqrtValue = yao.multiply(yao).subtract(halfDi.multiply(
                                   halfDi));
        BigDecimal gao = sqrt(sqrtValue, 20);
        return di.multiply(gao).divide(BigDecimal.valueOf(2), 20,
                                       RoundingMode.HALF_UP);
    }

    public static BigDecimal sqrt(BigDecimal num, int precision) {
        // 负数不能开平方
        if (num.compareTo(BigDecimal.ZERO) < 0) {
            throw new ArithmeticException("不能对负数开平方");
        }
        MathContext context = new MathContext(precision, RoundingMode.HALF_UP);
        BigDecimal guess = num.divide(BigDecimal.valueOf(2), context);
        BigDecimal tolerance = BigDecimal.ONE.scaleByPowerOfTen(-precision);
        while (true) {
            BigDecimal nextGuess = guess.add(num.divide(guess,
                                             context)).divide(BigDecimal.valueOf(2), context);
            if (nextGuess.subtract(guess).abs().compareTo(tolerance) <= 0) {
                return nextGuess;
            }
            guess = nextGuess;
        }
    }

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);
    }
}