fork download
copy 
  1. import math
  2.  
  3. class SumSolver:
  4.     def __init__(self):
  5.         # 基础配置 - 可根据需要修改
  6.         self.target = 219911.73       # 目标总和
  7.         self.coefficients = [38.5,44,61,70.5,75.5,93]  # 系数列表
  8.         self.max_product = 125000      # 单个系数乘积上限
  9.         self.fine_tune_index = 0      # 可微调的系数索引（默认第一个）
  10.         self.fine_tune_range = 1.0    # 微调范围
  11.         self.fine_tune_step = 0.1     # 微调步长
  12.         self.max_solutions = 4        # 最大返回解数量
  13.         self.balance_threshold = 0.3  # 平衡解判断阈值
  14.         self.error_tolerance = 0.1    # 允许的误差范围
  15.  
  16.     def set_parameters(self, **kwargs):
  17.         """灵活设置参数，支持修改任何配置"""
  18.         for key, value in kwargs.items():
  19.             if hasattr(self, key):
  20.                 setattr(self, key, value)
  21.             else:
  22.                 print(f"警告: 未知参数 {key}")
  23.         return self
  24.  
  25.     def find_solutions(self):
  26.         """寻找符合条件的解"""
  27.         # 排序系数，确保一致性
  28.         sorted_coeffs = sorted(self.coefficients)
  29.         a_base, others = sorted_coeffs[0], sorted_coeffs[1:]
  30.  
  31.         # 尝试原始系数
  32.         print(f"尝试原始系数: {sorted_coeffs}")
  33.         solutions = self._find_combination(a_base, *others)
  34.         if solutions:
  35.             self._print_solutions(sorted_coeffs, solutions)
  36.             return True
  37.  
  38.         # 尝试微调指定系数
  39.         print(f"\n原始系数未找到解，尝试微调第 {self.fine_tune_index+1} 个系数")
  40.         start = a_base - self.fine_tune_range
  41.         end = a_base + self.fine_tune_range
  42.         steps = int((end - start) / self.fine_tune_step) + 1
  43.  
  44.         for i in range(steps):
  45.             a = round(start + i * self.fine_tune_step, 1)
  46.             if a <= 0:
  47.                 continue
  48.  
  49.             print(f"尝试系数组合: [{a}, {', '.join(map(str, others))}]")
  50.             solutions = self._find_combination(a, *others)
  51.             if solutions:
  52.                 self._print_solutions([a] + others, solutions)
  53.                 return True
  54.  
  55.         print("\n未找到符合条件的解")
  56.         return False
  57.  
  58.     def _find_combination(self, a, b, c):
  59.         """寻找满足 a*x + b*y + c*z ≈ target 的整数解"""
  60.         solutions = []
  61.  
  62.         # 计算变量范围
  63.         max_x = min(int(self.max_product / a), int(self.target / a) + 100)
  64.         max_y = min(int(self.max_product / b), int(self.target / b) + 100)
  65.  
  66.         # 计算步长（确保不遗漏解）
  67.         step_x = max(1, max_x // 200)
  68.         step_y = max(1, max_y // 200)
  69.  
  70.         # 遍历可能的x和y值
  71.         for x in range(1, max_x + 1, step_x):
  72.             ax = a * x
  73.             if ax > self.max_product:
  74.                 continue
  75.  
  76.             remaining_after_x = self.target - ax
  77.             if remaining_after_x <= 0:
  78.                 continue
  79.  
  80.             for y in range(1, max_y + 1, step_y):
  81.                 by = b * y
  82.                 if by > self.max_product:
  83.                     continue
  84.  
  85.                 remaining_after_y = remaining_after_x - by
  86.                 if remaining_after_y <= 0:
  87.                     continue
  88.  
  89.                 # 计算z值
  90.                 z = remaining_after_y / c
  91.                 if not self._is_near_integer(z):
  92.                     continue
  93.  
  94.                 z = round(z)
  95.                 cz = c * z
  96.                 if cz > self.max_product or z <= 0:
  97.                     continue
  98.  
  99.                 # 检查总和是否在允许范围内
  100.                 total = ax + by + cz
  101.                 if abs(total - self.target) > self.error_tolerance:
  102.                     continue
  103.  
  104.                 # 判断是否为平衡解
  105.                 is_balanced = self._is_balanced([x, y, z])
  106.                 solutions.append((x, y, z, ax, by, cz, total, is_balanced))
  107.  
  108.                 if len(solutions) >= self.max_solutions:
  109.                     return solutions
  110.  
  111.         return solutions
  112.  
  113.     def _is_near_integer(self, value):
  114.         """判断一个值是否接近整数"""
  115.         return abs(value - round(value)) < 0.001
  116.  
  117.     def _is_balanced(self, variables):
  118.         """判断变量是否相对平衡"""
  119.         if len(variables) != 3:
  120.             return False
  121.  
  122.         min_var, max_var = min(variables), max(variables)
  123.         return (min_var / max_var) > self.balance_threshold if max_var != 0 else False
  124.  
  125.     def _print_solutions(self, coeffs, solutions):
  126.         """打印找到的解"""
  127.         labels = ['a', 'b', 'c']
  128.         coeff_str = ", ".join([f"{labels[i]}={coeffs[i]}" for i in range(3)])
  129.         print(f"找到解! 组合: {coeff_str} ({len(solutions)} 个有效解)")
  130.  
  131.         for i, (x, y, z, ax, by, cz, total, is_balanced) in enumerate(solutions, 1):
  132.             balance_label = " [平衡解]" if is_balanced else ""
  133.             print(f"  {i}. x={x}, y={y}, z={z}, a*x={ax}, b*y={by}, c*z={cz}, 总和={total}{balance_label}")
  134.  
  135. if __name__ == "__main__":
  136.     # 示例用法
  137.     solver = SumSolver()
  138.  
  139.     # 根据需要修改参数（示例：求解36.5、68.5、74表示101467.8）
  140.     solver.set_parameters(
  141.         target=101467.8,
  142.         coefficients=[36.5, 68.5, 74],
  143.         max_product=50000
  144.     )
  145.  
  146.     # 寻找解
  147.     solver.find_solutions()
  148.  
  149.     # 如需求解其他组合，直接修改参数即可，例如：
  150.     # solver.set_parameters(
  151.     #     target=28098,
  152.     #     coefficients=[38.5, 44, 61],
  153.     #     max_product=30000
  154.     # ).find_solutions()
  155.  
Success #stdin #stdout 0.12s 9476KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
尝试原始系数: [36.5, 68.5, 74]

原始系数未找到解，尝试微调第 1 个系数
尝试系数组合: [35.5, 68.5, 74]
尝试系数组合: [35.6, 68.5, 74]
找到解! 组合: a=35.6, b=68.5, c=74 (4 个有效解)
  1. x=218, y=682, z=635, a*x=7760.8, b*y=46717.0, c*z=46990, 总和=101467.8 [平衡解]
  2. x=288, y=718, z=568, a*x=10252.800000000001, b*y=49183.0, c*z=42032, 总和=101467.8 [平衡解]
  3. x=393, y=550, z=673, a*x=13990.800000000001, b*y=37675.0, c*z=49802, 总和=101467.8 [平衡解]
  4. x=463, y=586, z=606, a*x=16482.8, b*y=40141.0, c*z=44844, 总和=101467.8 [平衡解]
https://ideone.com/H4kXJr
language:
Python 3 nbc (python 3.7.3)
created:
7 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!