短答案已经分更高，为什么还不能提前结束搜索？

"""Finite search without beam pruning. Length counts EOS, excludes the prompt."""
import csv
import json
import math
from fractions import Fraction as F
from pathlib import Path

ROOT = Path(__file__).resolve().parent
MAX_LENGTH = 3
CASES = [
    {"id": "unsafe_current_score", "root_A": "3/5", "A_EOS": "4/5"},
    {"id": "safe_early_stop", "root_A": "9/10", "A_EOS": "9/10"},
]


def tree_for(case):
    a, eos = F(case["root_A"]), F(case["A_EOS"])
    assert 0 < a < 1 and 0 < eos < 1
    return {
        (): {"A": a, "B": 1 - a},
        ("A",): {"EOS": eos, "x": 1 - eos},
        ("B",): {"x": F(1)},
        ("A", "x"): {"EOS": F(1)},
        ("B", "x"): {"EOS": F(1)},
    }


def check_tree(tree):
    for prefix, edges in tree.items():
        assert len(prefix) < MAX_LENGTH and "EOS" not in prefix
        assert sum(edges.values()) == 1
        assert all(0 < p <= 1 for p in edges.values())
        for token in edges:
            assert token == "EOS" or prefix + (token,) in tree


def better(left, right):
    """Compare mean log probabilities exactly, without computing a log."""
    if right is None:
        return True
    lp, rp = left[1], right[1]
    return lp ** len(right[0]) > rp ** len(left[0])


def best_of(items):
    best = None
    for item in items:
        if better(item, best):
            best = item
    return best


def enumerate_leaves(tree, prefix=(), probability=F(1)):
    leaves = []
    for token, conditional in tree[prefix].items():
        path, mass = prefix + (token,), probability * conditional
        if token == "EOS":
            leaves.append((path, mass))
        else:
            leaves.extend(enumerate_leaves(tree, path, mass))
    return leaves


def may_stop(best, active, policy):
    if best is None:
        return False
    if not active:
        return True
    if policy == "unsafe_current":
        return all(not better(prefix, best) for prefix in active)
    assert policy == "bounded"
    # log(prefix_mass) / MAX_LENGTH <= log(best_mass) / best_length
    return all(mass ** len(best[0]) <= best[1] ** MAX_LENGTH
               for _, mass in active)


def describe(item):
    path, mass = item
    return {"path": " ".join(path), "probability": str(mass), "length": len(path),
            "mean_log": math.log(float(mass)) / len(path),
            "geometric_mean": float(mass) ** (1 / len(path))}


def search(case_id, tree, policy):
    active, finished, ledger = [((), F(1))], [], []
    for depth in range(1, MAX_LENGTH + 1):
        expanded = []
        for prefix, mass in active:
            for token, conditional in tree[prefix].items():
                item = (prefix + (token,), mass * conditional)
                (finished if token == "EOS" else expanded).append(item)
        active = expanded
        best = best_of(finished)
        stop = may_stop(best, active, policy)
        ledger.append({"case": case_id, "policy": policy, "depth": depth,
                       "active_paths": " | ".join(" ".join(p) for p, _ in active),
                       "best_finished": " ".join(best[0]) if best else "",
                       "best_probability": str(best[1]) if best else "",
                       "best_length": len(best[0]) if best else "",
                       "largest_active_mass": str(max((p for _, p in active), default=F(0))),
                       "upper_bound_length": MAX_LENGTH, "stop": stop})
        if stop:
            assert best is not None
            return best, ledger
    raise AssertionError("The finite tree must finish by MAX_LENGTH")


def write_csv(name, rows):
    with (ROOT / name).open("w", encoding="utf-8", newline="") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0]))
        writer.writeheader()
        writer.writerows(rows)


def main():
    leaf_rows, ledger_rows, summaries = [], [], []
    for case in CASES:
        tree = tree_for(case)
        check_tree(tree)
        leaves = enumerate_leaves(tree)
        assert sum(mass for _, mass in leaves) == 1
        exhaustive = best_of(leaves)
        raw_best = max(leaves, key=lambda item: item[1])
        runs = {}
        for policy in ("unsafe_current", "bounded"):
            chosen, ledger = search(case["id"], tree, policy)
            ledger_rows.extend(ledger)
            runs[policy] = {**describe(chosen), "stop_depth": ledger[-1]["depth"],
                            "matches_exhaustive": chosen == exhaustive}
        assert runs["bounded"]["matches_exhaustive"]
        leaf_rows.extend({"case": case["id"], **describe(item)} for item in leaves)
        summaries.append({"case": case["id"], "raw_probability_best": describe(raw_best),
                          "exhaustive_mean_log_best": describe(exhaustive), "searches": runs})
    assert summaries[0]["searches"]["unsafe_current"]["matches_exhaustive"] is False
    assert summaries[0]["searches"]["bounded"]["path"] == "B x EOS"
    assert summaries[1]["searches"]["bounded"]["stop_depth"] == 2
    assert may_stop(None, [], "bounded") is False
    assert may_stop((("A", "EOS"), F(1)), [], "bounded") is True
    assert better((("a",), F(1, 2)), (("b", "EOS"), F(1, 4))) is False
    inputs = {"max_length": MAX_LENGTH, "length_counts_eos": True,
              "length_excludes_prompt": True, "cases": CASES}
    report = {"scope": "Exact finite toy tree; no beam pruning, model, training, or quality evaluation",
              "objective": "mean natural log probability; exponent 1; ties retain first candidate",
              "comparisons": "Exact rational powers; floats only for displayed log/geometric mean",
              "upper_bound": "log(prefix_probability) / max_length",
              "cases": summaries, "leaf_rows": len(leaf_rows), "ledger_rows": len(ledger_rows)}
    (ROOT / "length-inputs.json").write_text(json.dumps(inputs, indent=2) + "\n", encoding="utf-8")
    (ROOT / "length-report.json").write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
    write_csv("length-leaves.csv", leaf_rows)
    write_csv("length-stopping.csv", ledger_rows)
    print(f"PASS length_stop: {len(CASES)} cases, {len(leaf_rows)} leaves, {len(ledger_rows)} stopping rows")


if __name__ == "__main__":
    main()