refactor

app.py

@@ -3,6 +3,7 @@ import pandas as pd
 import pulp
 import numpy as np
 from numpy.typing import NDArray
+from pyscipopt import Model, quicksum
 
 # Define the quality tiers and names for the plants
 PLANTS_TIERS = {
@@ -105,70 +106,83 @@ def calculator(*args):
              the total gold earned, and the remaining inventory.
              Returns an error message if no solution is found.
     """
-    budget: int = args[0]  # 葭碧预算
-    strategy: str = args[1]  # 出售策略
-    extra_rate: int = args[2]  # 高价收购倍率
+    currency, budget, strategy, extra_rate = args[0:4]
+    # budget: int = args[0]  # 葭碧预算
+    # strategy: str = args[1]  # 出售策略
+    # extra_rate: int = args[2]  # 高价收购倍率
     stocks: NDArray[np.int_ | np.integer] = np.array(
-        [x if x else 0 for x in args[3:]]
+        [x if x else 0 for x in args[4:]]
     )  # 植物库存
 
-    # 植物名称列表
+    # Plant names and prices
     plants_names = [
         f"{PLANTS_TIERS[row['tier']]} {PLANTS_LABLES[row['species']]}"
         for index, row in df.iterrows()
     ]
+    price = df[currency]  # 植物单价
+    sold_prices = np.array(price * (1 + extra_rate))
 
-    gold = df["gold"]  # 植物单价
-    sold_prices = np.array(gold * (1 + extra_rate))
+    # Initialize the master problem
+    model = Model("BewilderingBlossom")
 
-    if sum([sold_prices[i] * stocks[i] for i in range(len(stocks))]) < budget:
-        return "No solution found.\nThe total value of the plants is lower than the budget."
-
-    # 创建问题实例，根据出售策略设定优化目标
-    if strategy == "MaximizeStock":
-        prob = pulp.LpProblem("Maximize_Stock", pulp.LpMinimize)
-    else:
-        prob = pulp.LpProblem("Minimize_Stock", pulp.LpMaximize)
+    # Decision variables in master problem
+    x = [
+        model.addVar(
+            vtype="I", name=f"x_{i}", lb=0, ub=int(stocks[i]) if stocks[i] else 0
+        )
+        for i in range(len(stocks))
+    ]
 
-    # 决策变量，售出每种植物的件数，必须是整数
-    x = pulp.LpVariable.dicts("x", range(len(stocks)), lowBound=0, cat="Integer")
+    obj1 = quicksum(sold_prices[i] * x[i] for i in range(len(stocks)))
+    obj2 = quicksum(x[i] for i in range(len(stocks)))
 
-    # 遍历，设置决策变量的上界为库存量
-    for i in range(len(stocks)):
-        x[i].upBound = stocks[i]
+    # Objective: maximize total value of sold plants
+    model.setObjective(obj1, "maximize")
 
-    # 目标函数：最大化 / 最小化 售出株数
-    prob += pulp.lpSum([x[i] for i in range(len(stocks))])
+    model.addCons(obj1 <= budget)
 
-    # 约束条件：每类产品售出数量乘以单价之和等于总价格
-    prob += pulp.lpSum([sold_prices[i] * x[i] for i in range(len(stocks))]) == budget
+    # first optimize
+    model.hideOutput()
+    model.optimize()
 
-    # 求解问题
-    # CBC(Coin-or Branch and Cut)求解器使用分支定界算法来寻找整数规划问题的最优解
-    solver = pulp.PULP_CBC_CMD(mip=True, msg=False)
-    prob.solve(solver=solver)
+    if model.getStatus() == "optimal":
+        optimal_total_value = model.getObjVal()
+        model.freeTransform()
 
-    if pulp.LpStatus[prob.status] == "Optimal":
+        model.setObjective(
+            obj2, "maximize" if strategy == "MinimizeStock" else "minimize"
+        )
+        model.addCons(obj1 == optimal_total_value)
+        model.optimize()
 
-        sold = 0
+        # Final solution processing
         solution = []
-        for i, v in x.items():
-            if v.varValue:
-                if v.varValue > 0:
+        # total_price = 0
+        # total_count = 0
+
+        if model.getStatus() == "optimal":
+            for i, var in enumerate(x):
+                if (v := int(model.getVal(var))) > 0 and sold_prices[i] > 0:
                     solution.append(
-                        f"{plants_names[i]}(${sold_prices[i]}): {int(v.varValue)}\n"
+                        f"{plants_names[i]} ({sold_prices[i]} {currency}): {v}\n"
                     )
-                    sold += int(v.varValue) * sold_prices[i]
-
-        return f"Optimal solution found:\n\n{''.join(solution)}\nTotal Price: {sold}\nCount: {int(pulp.value(prob.objective))}"
-
+                    # total_price += v * sold_prices[i]
+                    # total_count += v
+
+            if optimal_total_value == budget:
+                return f"\nGreat! Found a combination of items with a total value equal to the budget ({budget} {currency}).😃\n\n{''.join(solution)}\nTotal Price: {int(optimal_total_value)} {currency}\n"  # Count: {int(model.getObjVal())}
+            else:
+                return f"Oops! {int(budget - optimal_total_value)} {currency} short of the target value ({budget} {currency}).😂\n\n{''.join(solution)}\nTotal value: {int(optimal_total_value)} {currency}\n"  # Count: {int(model.getObjVal())}
+        else:
+            return "No solution found for the second optimization!"
     else:
-        return f"Can't find a combination of plants such that the sum of their values equals ${budget}. \nTry again with different inputs."
+        return "No solution found for the first optimization!"
 
 
 # 高亮每种植物的最高品质
 css = """
-.firstbox {background-color: #fafad2}
+.first-gold-box {background-color: #fafad2}
+.first-gems-box {background-color: #fed9b4}
 """
 
 with gr.Blocks(css=css) as demo:
@@ -177,26 +191,27 @@ with gr.Blocks(css=css) as demo:
         <center><font size=8>HP-Magic-Awakened Herbologist Toolkit👾</font></center>
 
         This program is essentially a solver for a variant of the knapsack problem. 
-        Due to the limitations of the third-party library used, this program can only return solutions that exactly match the target amount. 
-        Another more versatile [application](https://huggingface.co/spaces/oh-my-dear-ai/easy-knapsack-problem), however, can return solutions that maximize value while being less than or equal to the target amount.
+        Another more versatile [application](https://huggingface.co/spaces/oh-my-dear-ai/easy-knapsack-problem).
         """
     )
 
-    # Language selection dropdown
-    # language = gr.Radio(
-    #     choices=["cn", "en"],
-    #     value="cn",
-    #     label="Language",
-    #     info="Select the interface language:",
-    #     interactive=True,
-    # )
+    gold_or_gems = gr.State("gold")
 
     # Create a Gradio interface with a column layout
     with gr.Column():
+        # Add a row for the currency selection
+        currency_radio = gr.Radio(
+            choices=["gold", "gems"],
+            value="gold",
+            type="value",
+            label="Currency",
+            info="Select the currency:",
+            render=True,
+        )
         # Add a row for the budget input
         budget = gr.Number(
-            label="Gold",
-            info="Gabby's Gold Budget:",  # "葭碧の金币预算：",
+            label="Target",
+            info="Gabby's Budget:",  # "葭碧の金币预算：",
             value=0,
             minimum=0,
             maximum=20000,
@@ -205,9 +220,9 @@ with gr.Blocks(css=css) as demo:
         acquisition_rate = gr.Dropdown(
             choices=[
                 "0(Gabby's Acquisition)",
-                "+100%(Budding & Novice)",
-                "+200%(Junior & Practiced)",
-                "+300%(Natural & Master)",
+                "+100%(HVA for Budding & Novice)",
+                "+200%(HVA for Junior & Practiced)",
+                "+300%(HVA for Natural & Master)",
             ],
             value="0(Gabby's Acquisition)",
             type="index",
@@ -215,51 +230,68 @@ with gr.Blocks(css=css) as demo:
             info="Select your high-value acquisition rate:",
         )
 
-    # Add a radio selection for the strategy
-    selected_strategy = gr.Radio(
-        [
-            (
-                "Minimize the number of plants sold (prioritize high-priced plants)",
-                "MaximizeStock",
-            ),
-            (
-                "Maximize the number of plants sold (prioritize low-priced plants)",
-                "MinimizeStock",
-            ),
-        ],
-        value="MaximizeStock",
-        label="Strategies",
-        info="Select a strategy:",
-    )
+        # Add a radio selection for the strategy
+        selected_strategy = gr.Radio(
+            [
+                (
+                    "Minimize the number of plants sold (prioritize high-priced plants)",
+                    "MaximizeStock",
+                ),
+                (
+                    "Maximize the number of plants sold (prioritize low-priced plants)",
+                    "MinimizeStock",
+                ),
+            ],
+            value="MaximizeStock",
+            label="Strategies",
+            info="Select a strategy:",
+        )
+
+    def show_plant_boxes(currency):
+        # Update the state variable
+        gold_or_gems.value = currency
 
-    # Add a row for the plant inventory inputs
-    with gr.Row():
         inventory = {}
         species_set = set()
         species_count = 0
         for _, row in df.iterrows():
-            if is_gold := row["gold"] != 0:
+            # Check if the plant should be shown based on the selected currency
+            if row[currency] != 0:
                 species_set.add(row["species"])
-            inventory[f"{row['species']}_{row['tier']}"] = gr.Number(
-                # label=f"{PLANTS_I18N[row['species']]}_{PLANTS_TIERS[row['tier']]}",
-                label=PLANTS_LABLES[row["species"]],
-                info=PLANTS_TIERS[row["tier"]] + " $" + str(row["gold"]),
-                value=0,
-                precision=0,
-                minimum=0,
-                maximum=500,
-                step=10,
-                visible=is_gold,
-                elem_classes=("firstbox" if len(species_set) > species_count else None),
-            )
-            species_count = len(species_set)
+                # Create the Number component for the plant inventory
+                inventory[f"{row['species']}_{row['tier']}"] = gr.Number(
+                    label=PLANTS_LABLES[row["species"]],
+                    info=f"{PLANTS_TIERS[row['tier']]} ${row[currency]}",
+                    value=0,
+                    precision=0,
+                    minimum=0,
+                    maximum=500,
+                    step=10,
+                    visible=True,
+                    elem_classes=(
+                        f"first-{currency}-box"
+                        if len(species_set) > species_count
+                        else None
+                    ),
+                )
+                species_count = len(species_set)
+            else:
+                # If not shown, create a dummy invisible component
+                inventory[f"{row['species']}_{row['tier']}"] = gr.Number(visible=False)
+
+        # Return the updated inventory components
+        return list(inventory.values())
+
+    # Create the dynamic plant inventory inputs
+    with gr.Row() as inventory_row:
+        inventory = show_plant_boxes(gold_or_gems.value)
 
     # Add a row for the Clear and Calculate buttons
     with gr.Row():
-        clear_btn = gr.ClearButton(list(inventory.values()), size="sm", value="❌Clear")
+        clear_btn = gr.ClearButton(inventory, size="sm", value="❌Clear")
 
-        # Add a button to trigger the calculation
-        submit_btn = gr.Button(value="🛠Calculate")
+    # Add a button to trigger the calculation
+    submit_btn = gr.Button(value="🛠Calculate")
 
     # Add a row for the result textbox
     with gr.Row():
@@ -268,14 +300,18 @@ with gr.Blocks(css=css) as demo:
     # Set up the button click event to call the calculator function
     submit_btn.click(
         calculator,
-        inputs=[budget]
-        + [selected_strategy]
-        + [acquisition_rate]
-        + list(inventory.values()),
+        inputs=[gold_or_gems, budget, selected_strategy, acquisition_rate] + inventory,
         outputs=[result],
         api_name=False,
     )
 
+    # Update the inventory when the currency changes
+    currency_radio.change(
+        fn=lambda selected_currency: show_plant_boxes(selected_currency)
+        + [selected_currency],  # Adjusted function to return only the components
+        inputs=currency_radio,
+        outputs=inventory + [gold_or_gems],  # Update each child in the inventory_row
+    )
 
 # Launch the Gradio application
 demo.queue(api_open=False)

plants.csv

@@ -128,10 +128,17 @@ gold,gems,species,tier
 58,0,mosaic_flower,hardy_rarecolor
 52,0,mosaic_flower,hardy
 1,0,mosaic_flower,feeble
+0,5,sunflower,radiant_rarecolor
 0,4,sunflower,radiant
+106,0,sunflower,flourishing_rarecolor
 96,0,sunflower,flourishing
+83,0,sunflower,hardy_rarecolor
 75,0,sunflower,hardy
 1,0,sunflower,feeble
+62,0,mimbulus_mimbletonia,radiant
+
+39,0,mimbulus_mimbletonia,hardy
+1,0,mimbulus_mimbletonia,feeble
 299,0,water_lily,radiant_rarecolor
 271,0,water_lily,radiant
 244,0,water_lily,flourishing_rarecolor