假设你现在有1000颗星星，

每轮游戏池子总积分数暂定为1000，星星数固定为5颗

因为每轮游戏产出星星概率可以由本人投入积分/池子积分总数计算，考虑这两种极端情况：

1：投入 Z = 1000 点，一把梭哈

• 总点数池 P = 1000 (你) + 1000 (他人) = 2000 点

• 获胜几率 Prob_Win = 1000 / 2000 = 0.5

• 预期获得星星: 0.5 * 5 ≈ 2.5 星

2：投入投入 Z = 1000 点，一把梭哈

• 总点数池 P = 000 (你) + 1000 (他人) = 1100 点

• 获胜几率 Prob_Win = 100 / 1100 = 0.0909

• 预期获得星星: 0.0909*5*10=4.545 星

不难看出总星星数是关于每次投入积分的反比例函数y=x(10000/x)/(x+1000),星星期望随投入积分数增加而降低。

考虑到每轮池子积分的动态变化，以及奖池星星基数的改变(目前发现池子在8000分左右星星基数变为2)，假定个人积分总量为1w，改变平均下注的积分数量绘制下面的三维图像

截取池子（他人）积分为5000时的函数图像为例，由于投入积分数为3125时星星基数改变发生断层现象，星星期望达到最高

对星星的计算有了初步判断后还要考虑积分返佣规则

“划算度”的完整数学模型

1. 基础定义：

   • B：你的出价 (Your Bid)

   • P_others：池中其他人已出价的总和 (Sum of Others' Bids)

   • P_total：总点数池 = B + P_others

2. 获胜几率 (Prob_Win)：

   • Prob_Win = B / P_total (假设 P_total > 0)

3. 星星奖励 (Star_Prize)：

   • 固定乘数 = 5x

   • 如果 P_total < 8000，基础星星 = 1 => Star_Prize = 1 * 5 = 5 星

   • 如果 P_total >= 8000，基础星星 = 2 => Star_Prize = 2 * 5 = 10 星

4. 期望星星数 (E_Stars)：

   • E_Stars = Prob_Win * Star_Prize

   • 如果你的出价 B < 100 (最低出价限制)，则 E_Stars = 0 (因为无法有效出价)。

5. 预期净点数成本 (E_Cost)：

   • E_Cost = 0.95 * B - 0.01 * P_others

   • 这个值代表平均每次出价后，你点数的净损失。

     • E_Cost > 0：平均亏损点数。

     • E_Cost = 0：平均点数不亏不赚。

     • E_Cost < 0：平均净赚点数 (即 预期净点数变化 E_Points_Change 为正)。

6. “划算度” (Efficiency, Eff)：

   • 核心定义： Eff = E_Stars / E_Cost

   • 适用条件： 这个核心定义主要适用于 E_Cost > 0 的情况，它表示你每平均付出1点净成本的点数，期望能换回多少星星。值越大，越划算。

   • 特殊情况处理 (为了图像和理解)：

     • 如果 E_Stars = 0 (例如 B < 100): Eff = 0。

     • 如果 E_Stars > 0 且 E_Cost <= 0 (即点数上不亏或能赚点，同时还能期望获得星星): 这是非常理想的情况，其“划算度”可以认为是极高甚至是“无限大”。在绘图时，我们会赋予这些情况一个非常高的正值，以区别于有成本的情况。

       • 若 E_Cost = 0 (点数持平)：划算度视为“极高A”。

       • 若 E_Cost < 0 (点数净赚)：划算度视为“极高B”（比“极高A”更高，因为不仅不花钱还有的赚）。

构建模型图像如下，发现当前池子积分>1w时，投入积分数在100左右性价比急速上升，也就是说投入100积分就算输了也会返还100积分，相当于投注永动机，不知道后面人多了项目方会不会修改机制，另外不清楚人数超过了95后池子的奖励会如何分配

那么我们如何Bid性价比最高呢

1 小注多次

2 凑断点位置

3 池子量及大或及小时优先Bid

py脚本模型，可以通过当前池子已经积分数量判断需要投入多少代币

(模型不一定准确后续需要一定修改)：

import numpy as np
import pandas as pd

MINIMUM_BID = 100
TGP_FIXED = 10000 # 我们分析的基础：固定总投入预算为10000点
B_EACH_MAX_ANALYSIS = 5000 # 单次出价B_each的分析上限

def calculate_expected_stars(your_bid_b, others_bid_p_others):
    if your_bid_b < MINIMUM_BID: 
        return 0 
    total_pool_p = your_bid_b + others_bid_p_others
    if total_pool_p == 0: 
        return 0
    prob_win = your_bid_b / total_pool_p
    star_prize = 5 if total_pool_p < 8000 else 10
    return prob_win * star_prize

if __name__ == '__main__':
    loop_counter = 0
    while True:
        loop_counter += 1
        print(f"\n--- [第 {loop_counter} 轮分析开始] ---")
        
        p_others_input_str = input("请输入当前池子中其他人的总点数 (P_others) (或输入 'exit' 退出): ")
        if p_others_input_str.lower() == 'exit':
            break
        
        my_points_input_str = input(f"请输入你当前拥有的点数 (My_Points_Available) (总预算分析仍基于{TGP_FIXED}点): ")
        
        try:
            p_others_manual = float(p_others_input_str)
            my_points_available = float(my_points_input_str)
            if p_others_manual < 0 or my_points_available < 0:
                print("点数不能为负数，请重新输入。")
                continue
        except ValueError:
            print("输入无效，请输入一个数字或 'exit'。")
            continue
        except Exception as e:
            print(f"发生错误: {e}")
            continue

        print(f"\n--- 理论分析：如何最优地花费 {TGP_FIXED} 点总预算 (当前P_others = {p_others_manual:.0f}) ---")
        print("目标：找到最优的单次出价额 (B_each)，以最大化累计期望星星总数。")
        print(f"总共会进行 N = {TGP_FIXED} / B_each 次出价。\n")

        # B_each 分析范围从100到B_EACH_MAX_ANALYSIS (5000)
        # 确保TGP_FIXED / B_each (当B_each = TGP_FIXED时，N=1) 这个点也被分析到，如果B_EACH_MAX_ANALYSIS < TGP_FIXED
        # 但我们是分析B_each的颗粒度，所以B_each不应超过TGP_FIXED，且不超过我们设定的B_EACH_MAX_ANALYSIS
        # 如果B_EACH_MAX_ANALYSIS本身就小于TGP_FIXED，那么N=1的情况（B_each=TGP_FIXED）就不在分析范围内了
        # 我们的目标是找到最优的B_each *粒度* 来花掉TGP_FIXED
        # 所以B_each应该可以达到TGP_FIXED，但分析时可以只观察到5000

        current_b_each_max = min(TGP_FIXED, B_EACH_MAX_ANALYSIS) # B_each不会超过总预算或设定的分析上限

        b_each_analysis_range = np.unique(np.concatenate(([MINIMUM_BID, current_b_each_max], 
                                                         np.logspace(np.log10(MINIMUM_BID), np.log10(current_b_each_max), 70).astype(int))))
        b_each_analysis_range = b_each_analysis_range[b_each_analysis_range >= MINIMUM_BID]
        b_each_analysis_range = b_each_analysis_range[b_each_analysis_range <= current_b_each_max] # Ensure it doesn't exceed
        b_each_analysis_range.sort()
        if len(b_each_analysis_range) == 0: # Should not happen if MINIMUM_BID <= current_b_each_max
             b_each_analysis_range = np.array([MINIMUM_BID])


        all_results = []
        for b_e in b_each_analysis_range:
            if b_e == 0: continue
            num_bids_n = TGP_FIXED / b_e # 花费10000点总预算需要多少次当前B_each的出价
            e_stars_per_one_bid = calculate_expected_stars(b_e, p_others_manual)
            total_e_stars = num_bids_n * e_stars_per_one_bid
            all_results.append({'B_each': b_e, 'N_bids_for_TGP': num_bids_n, 'Total_Exp_Stars_for_TGP': total_e_stars})

        df_results = pd.DataFrame(all_results)
        
        optimal_b_each_for_tgp = -1
        max_total_stars_for_tgp = -1.0
        optimal_n_bids_for_tgp = 0

        if not df_results.empty and 'Total_Exp_Stars_for_TGP' in df_results.columns and not df_results['Total_Exp_Stars_for_TGP'].isnull().all():
            valid_stars = df_results['Total_Exp_Stars_for_TGP'].dropna()
            if not valid_stars.empty:
                max_total_stars_for_tgp = valid_stars.max()
                if pd.notna(max_total_stars_for_tgp) and max_total_stars_for_tgp >= 0:
                    optimal_row = df_results.loc[df_results['Total_Exp_Stars_for_TGP'].idxmax()]
                    optimal_b_each_for_tgp = optimal_row['B_each']
                    optimal_n_bids_for_tgp = optimal_row['N_bids_for_TGP']
        
        # 准备表格输出
        b_each_table_display_samples = sorted(list(set([100, 200, 500, 1000, 2000, 3000, 4000, B_EACH_MAX_ANALYSIS])))
        if optimal_b_each_for_tgp != -1 and optimal_b_each_for_tgp not in b_each_table_display_samples:
            b_each_table_display_samples.append(int(optimal_b_each_for_tgp))
            b_each_table_display_samples.sort()
        b_each_table_display_samples = [b for b in b_each_table_display_samples if b >= MINIMUM_BID and b <= B_EACH_MAX_ANALYSIS]


        table_output_console = [f"\n--- 累计期望星星数表格 (P_others = {p_others_manual:.0f}, 总预算分析基于 {TGP_FIXED}点) ---"]
        header_console = f"{'单次出价 (B_each)':<18} | {'花完{TGP_FIXED}点需次数':<22} | {'累计期望星星数(预算{TGP_FIXED})':<28}"
        table_output_console.append(header_console)
        table_output_console.append("-" * len(header_console))
        
        for b_e_val in b_each_table_display_samples:
            if b_e_val == 0: continue
            n_val_table = TGP_FIXED / b_e_val
            e_stars_val_table = calculate_expected_stars(b_e_val, p_others_manual)
            total_s_table = n_val_table * e_stars_val_table
            table_output_console.append(f"{b_e_val:<18.0f} | {n_val_table:<22.1f} | {total_s_table:<28.3f}")
        
        print("\n".join(table_output_console))

        if optimal_b_each_for_tgp != -1 and max_total_stars_for_tgp >=0 :
            print(f"\n--- 理论最优策略总结 (针对 {TGP_FIXED}点总预算, P_others = {p_others_manual:.0f}) ---")
            print(f"为了最大化累计期望星星数 (用{TGP_FIXED}点总预算):")
            print(f" -> 理论上最优的单次出价额 (B_each) 为: {optimal_b_each_for_tgp:.0f} 点")
            print(f" -> 这相当于进行 {optimal_n_bids_for_tgp:.1f} 次这样的出价来花完 {TGP_FIXED} 点。")
            print(f" -> 预期的最大累计星星总数为: {max_total_stars_for_tgp:.3f} 星。")
            
            TARGET_POOL_FOR_10_STARS = 8000
            b_to_reach_8k_pool = TARGET_POOL_FOR_10_STARS - p_others_manual
            if MINIMUM_BID <= b_to_reach_8k_pool <= TGP_FIXED :
                if abs(optimal_b_each_for_tgp - b_to_reach_8k_pool) < 1 or \
                   (optimal_b_each_for_tgp == MINIMUM_BID and b_to_reach_8k_pool <= MINIMUM_BID) : 
                     print(f"   (提示: 当前P_others={p_others_manual:.0f}时，出价{optimal_b_each_for_tgp:.0f}点会使总池达到或刚超过8000点，触发10星奖励)")
            elif p_others_manual >= (TARGET_POOL_FOR_10_STARS - MINIMUM_BID) and optimal_b_each_for_tgp == MINIMUM_BID: 
                     print(f"   (提示: 当前P_others={p_others_manual:.0f}时，出价{MINIMUM_BID}点已能使总池达到或超过8000点，触发10星奖励)")
        else:
            print(f"\n对于 P_others = {p_others_manual:.0f}: 在当前B_each分析范围({MINIMUM_BID}-{B_EACH_MAX_ANALYSIS}点)内，未能找到期望星星为正的策略。")
        print("-" * 80)
        
        # --- 根据用户当前点数给出实际操作建议 ---
        if optimal_b_each_for_tgp != -1 and max_total_stars_for_tgp >=0:
            print(f"\n--- 基于你当前 {my_points_available:.2f} 点的实际操作建议 ---")
            if my_points_available < MINIMUM_BID:
                print("你的点数不足以进行最低出价。建议先积累点数。")
            elif my_points_available < optimal_b_each_for_tgp:
                print(f"你的点数 ({my_points_available:.2f}) 不足以按理论最优单次出价 ({optimal_b_each_for_tgp:.0f}点) 进行一次出价。")
                # 建议用100点出价
                num_100_bids_can_make = my_points_available // MINIMUM_BID # 可以进行的100点出价次数
                if num_100_bids_can_make > 0:
                    e_stars_per_100_bid = calculate_expected_stars(MINIMUM_BID, p_others_manual)
                    total_stars_with_100_bids = num_100_bids_can_make * e_stars_per_100_bid
                    print(f"你可以选择用 {MINIMUM_BID}点 进行 {num_100_bids_can_make:.0f} 次出价，预计总共获得 {total_stars_with_100_bids:.3f} 星。")
                else:
                    print("你甚至不足以进行一次100点的出价。")
                print("或者，你可以选择积攒更多点数，以便后续采用更优的单次出价策略。")
            else: # my_points_available >= optimal_b_each_for_tgp
                num_optimal_bids_can_make = my_points_available // optimal_b_each_for_tgp
                e_stars_per_optimal_bid = calculate_expected_stars(optimal_b_each_for_tgp, p_others_manual) # This is E_Stars for one bid of optimal_b_each
                total_stars_with_optimal_bids = num_optimal_bids_can_make * e_stars_per_optimal_bid
                
                print(f"你可以按理论最优单次出价 ({optimal_b_each_for_tgp:.0f}点) 进行 {num_optimal_bids_can_make:.0f} 次出价。")
                print(f"  预计这 {num_optimal_bids_can_make:.0f} 次出价总共能为你带来 {total_stars_with_optimal_bids:.3f} 星。")
                
                # 和用100点出价对比一下
                if optimal_b_each_for_tgp != MINIMUM_BID:
                    num_100_bids_can_make = my_points_available // MINIMUM_BID
                    if num_100_bids_can_make > 0:
                        e_stars_per_100_bid = calculate_expected_stars(MINIMUM_BID, p_others_manual)
                        total_stars_with_100_bids = num_100_bids_can_make * e_stars_per_100_bid
                        print(f"作为对比，如果用这 {my_points_available:.2f} 点全部以100点进行出价 ({num_100_bids_can_make:.0f}次)，预计总共获得 {total_stars_with_100_bids:.3f} 星。")
        else:
            print(f"\n--- 基于你当前 {my_points_available:.2f} 点的实际操作建议 ---")
            print("根据当前分析，在此P_others下，所有策略的期望星星数都非常低或为0。")
            if my_points_available >= MINIMUM_BID:
                print(f"如果你仍想参与，可以尝试用 {MINIMUM_BID} 点出价一次，但请注意期望收益可能不高。")
            else:
                print("你的点数不足以进行最低出价。")
        print("-" * 80)
        print("[调试] 完成一轮分析，准备返回循环开头接收新输入或退出。")

    print("\n程序已退出。")
    # input("按回车键关闭此窗口...") # 如果在IDE中运行，这句可能不需要；如果直接运行py文件，可以保留