2023 The Ninth Dimensional Cup Question D Modeling Analysis, Senior Xiaolu Leads the Team to Guide Full Code Articles and Ideas

I am senior Xiaolu, studying at Shanghai Jiao Tong University. So far, I have helped more than 200 people complete modeling and idea building~

This time I will take you to experience Question D of the 9th Digital Dimension Cup!

Question 1: Best cleaning method

In question one we want to consider what is the best way to clean given the amount of dirt and the amount of water available, by choosing an appropriate solubility (a_k).

First, we can build a mathematical model to describe the change process of dirt:

$$C_k=(1-a_k)C_{k-1}$$

In that,$C_k$ is the first $The\; amount\; of\; dirt\; after\; k$ cleaning times, $C_{k-1}$ is the first $k-1$Amount of scum after washing,$a_k$ is the first $Dirt\; solubility\; during\; k$ cleanings.

The goal is to minimize the total amount of dirt:

$C_{\text{total}}={\sum }_{k=1}^n{C}_k$

Considering the limit of available water, we can introduce a water limit condition:

${\sum }_{k=1}^n{IN}_k\le {IN}_{\text{total}}$

In that,${IN}_k$ is the first $k$ Amount of water used for next cleaning,${IN}_{\text{total}}$is the total amount of water available.

Now, we can use mathematical optimization methods (such as linear programming or nonlinear programming) to solve this problem and find the minimum total dirt amount $a_k$sum ${IN}_k$The combination.

关于 $ak$, initial scale amount $C_0$ Total available water ${IN}_{\text{total}}$The impact on the target can be discussed by performing a sensitivity analysis on the model. Conduct simulations or numerical experiments under different parameter values ​​to observe how the optimal solution changes as these parameters change, thereby drawing conclusions about their impact on the objectives.

Further discussion about $a_k$, initial dirt amount$C_0$ Total available water ${IN}_{\text{total}}$Impact on the optimal solution

1. effect $a_k$the elements of:

   • 初值 $a_1$ Target selection: Yuyu $a_k=0.5a_{k-1}$，初值 $a_1$The choice of will have an important impact on the entire cleaning process. if $a_1$Larger values ​​may result in poorer cleaning results because solubility decreases with increasing number of cleanings.
   • Solubility Decrease Rate $0.5$： $The\; choice\; of\; 0.5$ affects the rapid decrease in solubility. A smaller ramp-down rate will result in a slower decrease in solubility and may require more cleaning cycles to achieve desired cleaning results.

2. Influence the initial dirt amount $C_0$the elements of:

   • Initial dirt amount $C_0$Size of : Greater initial dirt volume may require more washes to achieve the same cleaning effect. Where water is limited, a larger volume of water may be required to handle a larger initial volume of dirt.

3. Available water volume ${IN}_{\text{total}}$the elements of:

   • Water limit ${IN}_{\text{total}}$ Size: Smaller water restrictions may result in less than ideal cleaning results. Where water is limited, higher solubility may be required $a_k$or less initial dirt volume to accommodate water volume limitations.

import numpy as np
from scipy.optimize import minimize

def objective_function(variables):
    # 定义目标函数，即总污垢量
    ak_values = variables[:n]
    Vk_values = variables[n:]
    
    Ck_values = [C0]
    for k in range(1, n+1):
        Ck_values.append((1 - ak_values[k-1]) * Ck_values[k-1])
    
    return np.sum(Ck_values)

def constraint(variables):
    # 定义约束条件，即水量限制
    Vk_values = variables[n:]
    return V_total - np.sum(Vk_values)

# 初始参数
n = 10  # 清洗次数
C0 = 100  # 初始污垢量
V_total = 500  # 可用水量

# 设置初始猜测值
initial_guess = np.ones(2 * n)  # [a1, a2, ..., an, V1, V2, ..., Vn]

# 设置约束条件
constraint_definition = {'type': 'ineq', 'fun': constraint}

# 优化器
result = minimize(objective_function, initial_guess, constraints=constraint_definition)

# 提取最优解
optimal_ak_values = result.x[:n]
optimal_Vk_values = result.x[n:]

# 输出结果
print("最优清洁方法：")
print("最优的ak值：", optimal_ak_values)
print("最优的Vk值：", optimal_Vk_values)
print("最小总污垢量：", result.fun)

Question two:

Question 2: The most time-saving cleaning plan

In question two, we assume that each cleaning takes the same amount of time and that there is no limit on the available water. The optimization goal is to find the most time-saving cleaning plan to ensure that the final dirt residue does not exceed one thousandth of the initial dirt amount.

First, we can build a mathematical model to describe the change process of dirt:

$$C_k=(1-a_k)C_{k-1}$$

In that,$C_k$ is the first $The\; amount\; of\; dirt\; after\; k$ cleaning, $C_{k-1}$ is the first $k-1$ Amount of scum after washing in the next clearing,$a_k$ is the first $Dirt\; solubility\; in\; k$ washes.

Since each cleaning takes the same amount of time, we can use the same time unit. Assume the time required for each cleaning is $T$, Cleaning order $n$。

The optimization goal is to minimize the total cleaning time:

$$T_{\text{total}}=n\cdot T$$

At the same time, it is necessary that the final amount of dirt residue does not exceed one thousandth of the initial amount of dirt:

$$C_n\le \frac{C_0}{1000}$$

Now, we can use mathematical optimization methods such as linear programming or nonlinear programming to solve this problem and find the combination of (a_k) and (n) that minimizes the total cleaning time.

effect $a_k$ and initial dirt amount $C_0$the elements of:

1. $a_k$ Target effect： Further $a_k$May cause faster dissolution of dirt, resulting in fewer washes and shorter overall wash time.
2. Initial dirt amount $C_0$Effect of : Larger initial dirt volumes may require more cleaning cycles to achieve final requirements, thereby increasing the total cleaning time.

Use the optimizer from the SciPy library:

import numpy as np
from scipy.optimize import minimize

def objective_function(variables):
    # 定义目标函数，即总清洗时间
    ak_values = variables[:n]
    Ck_values = [C0]
    
    for k in range(1, n+1):
        Ck_values.append((1 - ak_values[k-1]) * Ck_values[k-1])
    
    return n * T

def constraint(variables):
    # 定义约束条件，即最终的污垢残留量不超过初始污垢量的千分之一
    ak_values = variables[:n]
    Ck_values = [C0]
    
    for k in range(1, n+1):
        Ck_values.append((1 - ak_values[k-1]) * Ck_values[k-1])
    
    return Ck_values[-1] - C0 / 1000

# 初始参数
n = 10  # 清洗次数
C0 = 100  # 初始污垢量
T = 1  # 每次清洗所需时间

# 设置初始猜测值
initial_guess = np.ones(n)  # [a1, a2, ..., an]

# 设置约束条件
constraint_definition = {
    
    'type': 'ineq', 'fun': constraint}

# 优化器
result = minimize(objective_function, initial_guess, constraints=constraint_definition)

# 提取最优解
optimal_ak_values = result.x

# 输出结果
print("最省时的清洗计划：")
print("最优的ak值：", optimal_ak_values)
print("最小总清洗时间：", result.fun)

Question 3: Cost-saving and effective cleaning solution

In this question, we need to consider the price, solubility, and water costs of different detergents to find a solution that is both cost-effective and effective in cleaning. We can model this problem using linear programming.

Define variable declaration:

• $D_i$: No. $Amount\; of\; i$ detergent used (in liters)
• $a_{ik}$: No. $i$ 种wash涤剂在数 $k$ Solubility in dirt during cleaning
• $P_i)：第 $The\; unit\; price\; of\; i$ detergents
• $C_{\text{water}}$: Water cost (price per ton of water)
• ${IN}_k$: No. $k$ Amount of water used for cleaning

Establish a multivariate analysis mathematical model:

目标函数：
$$\text{Minimize }Z=\sum _{i=1}^{10}(D_i\cdot P_i)+C_{\text{water}}\cdot \sum _{k=1}^n{IN}_k$$

Restrictions:

1. Scale solubility:$$C_k=(1-\sum _{i=1}^{10}{a}_{ik}\cdot D_i)\cdot C_{k-1}$$
2. The final residual amount of dirt does not exceed one thousandth of the initial amount of dirt:$$C_n\le \frac{C_0}{1000}$$
3. Water limit:$$\sum _{k=1}^n{IN}_k\le {IN}_{\text{total}}$$
4. Washing amount usage penalty:$$D_i\ge 0,\text{ for }i=1,2,...,10$$
5. Water quantity is non-negative:$${IN}_k\ge 0,\text{ for }k=1,2,...,n$$

Next, we can use linear programming tools, such as the linprog function in the SciPy library, to solve this problem.

Here is a simplified Python code example:

import numpy as np
from scipy.optimize import linprog

# 初始参数
n = 10  # 清洗次数
C0 = 100  # 初始污垢量
V_total = 500  # 可用水量
C_limit = C0 / 1000  # 最终的污垢残留量不超过初始污垢量的千分之一
Ck_values = [C0]

# 表2中的洗涤剂数据
a_values = np.array([[0.2, 0.3, ..., 0.1],  # 洗涤剂1的溶解度
                     [0.1, 0.2, ..., 0.3],  # 洗涤剂2的溶解度
                     ...
                     [0.4, 0.1, ..., 0.2]])  # 洗涤剂10的溶解度

P_values = np.array([2.5, 1.8, ..., 3.0])  # 洗涤剂的单位价格

# 定义线性规划问题
c = np.concatenate((P_values, np.ones(n)))  # 目标函数系数
A_eq = np.zeros((n+1, 2*n))  # 等式约束矩阵
b_eq = np.zeros(n+1)  # 等式约束右侧

# 设置等式约束矩阵和右侧
for k in range(1, n+1):
    A_eq[k, :n] = -a_values[:, k-1]
    A_eq[k, n+k-1] = C0
    b_eq[k] = Ck_values[-1]

# 设置水量限制
A_ub = np.zeros((1, 2*n))  # 不等式约束矩阵
b_ub = np.array([V_total])  # 不等式约束右侧
A_ub[0, n:] = 1

# 设置边界
bounds = [(0, None) for _ in range(2*n)]

# 使用线性规划求解
result = linprog(c, A_eq=A_eq, b_eq=b_eq, A_ub=A_ub, b_ub=b_ub, bounds=bounds, method='highs')

# 提取最优解
optimal_D_values = result.x[:n]
optimal_V_values = result.x[n:]

# 输出结果
print("最省成本又能够有效清洁的方案：")
print("最优的洗涤剂使用量：", optimal_D_values)
print("最优的水量使用量：", optimal_V_values)
print("最小总成本：", result.fun)

Let’s learn more about it~
Xiaolu Senior Dimensional Cup D Question Full Code Articles and Ideas