import itertools

# 配置参数
TARGET_VALUE = 28098  # 目标值
BASE_COEFFICIENTS = [38.5, 44, 61, 70.5, 75.5, 93]  # 基础系数列表
MAX_PRODUCT = 129000  # 单个系数乘积的严格上限
VARIABLE_RATIO_TOLERANCE = 0.4  # 变量间比例容忍度
COEFFICIENT_GROUPS = [
    (70.5, 75.5, 93),  # 优先搜索的系数组合（按从小到大排序对应a,b,c）
    (61, 70.5, 93),
    (61, 75.5, 93),
    (61, 70.5, 75.5)
]

def find_similar_solutions():
    """寻找与示例解模式相似的解"""
    # 搜索优先系数组合（已按从小到大排序）
    for coeffs in COEFFICIENT_GROUPS:
        solutions = find_three_variable_solutions(coeffs)
        if solutions:
            print_solutions_group(coeffs, solutions)
            return
    
    # 扩大搜索范围，所有组合按从小到大排序
    for combo in itertools.combinations(BASE_COEFFICIENTS, 3):
        coeffs = sorted(combo)  # 确保系数按从小到大排序
        if coeffs in COEFFICIENT_GROUPS:
            continue
        solutions = find_three_variable_solutions(coeffs)
        if solutions:
            print_solutions_group(coeffs, solutions)
            return
    
    print("未找到符合条件的解")

def are_variables_balanced(vars):
    """判断变量是否均衡分布"""
    if len(vars) != 3:
        return False
    
    a, b, c = sorted(vars)
    ratio1 = a / c
    ratio2 = b / c
    in_range = all(500 <= v <= 2000 for v in vars)
    
    return ratio1 > (1 - VARIABLE_RATIO_TOLERANCE) and \
           ratio2 > (1 - VARIABLE_RATIO_TOLERANCE / 2) and \
           in_range

def find_three_variable_solutions(coeffs):
    """寻找三变量解，系数按从小到大排序（a,b,c）"""
    a, b, c = coeffs  # a:最小系数, b:中间系数, c:最大系数
    solutions = []
    
    # 计算变量可能的范围
    max_x = min(int(MAX_PRODUCT / a), 2000)
    max_y = min(int(MAX_PRODUCT / b), 2000)
    min_x = max(500, int((TARGET_VALUE * 0.2) / a))
    min_y = max(500, int((TARGET_VALUE * 0.2) / b))
    
    # 减小步长以找到更多解
    step = max(1, (max_x - min_x) // 300)
    for x in range(min_x, max_x + 1, step):
        ax = a * x
        if ax > MAX_PRODUCT:
            continue
            
        remaining_after_ax = TARGET_VALUE - ax
        if remaining_after_ax <= 0:
            continue
            
        for y in range(min_y, max_y + 1, step):
            by = b * y
            if by > MAX_PRODUCT:
                continue
                
            remaining_after_by = remaining_after_ax - by
            if remaining_after_by <= 0:
                continue
                
            # 计算z的值（对应最大系数c）
            z = remaining_after_by / c
            if not z.is_integer() or not (500 <= z <= 2000):
                continue
                
            z = int(z)
            cz = c * z
            if cz > MAX_PRODUCT:
                continue
                
            # 检查总和
            total = ax + by + cz
            if abs(total - TARGET_VALUE) > 1:
                continue
                
            # 检查是否为平衡解
            is_balanced = are_variables_balanced([x, y, z])
            
            solutions.append((x, y, z, ax, by, cz, total, is_balanced))
            
            # 找到4个解后停止
            if len(solutions) >= 4:
                return solutions
    
    return solutions

def print_solutions_group(coeffs, solutions):
    """按照指定格式打印找到的解组"""
    a, b, c = coeffs  # a:最小系数, b:中间系数, c:最大系数
    print(f"组合: a={a}, b={b}, c={c} ({len(solutions)} 个有效解)")
    
    for i, (x, y, z, ax, by, cz, total, is_balanced) in enumerate(solutions, 1):
        balance_label = " [平衡解]" if is_balanced else ""
        
        # 按照要求的格式分行显示
        print(f"  {i}. x={x}, y={y}, z={z},")
        print(f"  a*x={ax}, b*y={by}, c*z={cz}, 总和={total}{balance_label}")

if __name__ == "__main__":
    find_similar_solutions()