使用Python解决采购最优化问题：遗传算法的应用与实现教程

问题描述

假设我们需要采购六类物资：A、B、C、D、E 和 F。在市场上有两家供应商可供选择，供应商X和供应商Y，其物资种类和价格如下：

• 供应商X：提供物资 A、B 和 C，价格分别为 4、3 和 2 元。
• 供应商Y：提供物资 C、D、E 和 F，价格分别为 5、4、3 和 7 元。

需要满足的采购条件如下：

• 每种物资必须至少采购一个单位。
• 在供应商X购买的物资总量不得超过10个单位。
• 在供应商Y购买的物资总量不得超过8个单位。

目标是找到一种最优的采购方案，以使总成本最低。

遗传算法解题思路

遗传算法是一种启发式算法，通过模拟自然选择和基因遗传来逐步优化解决方案。算法的主要步骤包括：

1. 初始化种群：随机生成一批初始采购方案。
2. 计算适应度：评估每个采购方案的总成本，越低的成本对应更高的适应度。
3. 选择：选择适应度较高的方案用于下一代的交叉和变异。
4. 交叉与变异：通过交换和随机变异生成新的采购方案。
5. 迭代：重复上述步骤，直到找到最优解或达到预定的迭代次数。

Python代码实现

下面的代码使用Python实现遗传算法求解采购最优化问题。

import random

# 定义物资和供应商数据
goods = ['A', 'B', 'C', 'D', 'E', 'F']
prices_x = {'A': 4, 'B': 3, 'C': 2}  # 供应商X的物资价格
prices_y = {'C': 5, 'D': 4, 'E': 3, 'F': 7}  # 供应商Y的物资价格

# 遗传算法的参数
population_size = 100  # 种群大小
generations = 200  # 迭代次数
mutation_rate = 0.1  # 变异概率

# 适应度计算函数：计算采购方案的总成本
def calculate_cost(solution):
    cost = 0
    count_x, count_y = 0, 0
    
    for item, (source, quantity) in solution.items():
        if source == 'X':
            cost += prices_x[item] * quantity
            count_x += quantity
        elif source == 'Y':
            cost += prices_y[item] * quantity
            count_y += quantity
    
    # 违反约束条件的惩罚
    if count_x > 10 or count_y > 8:
        return float('inf')  # 超出限制的方案代价无穷大
    
    return cost

# 随机初始化种群
def initialize_population():
    population = []
    for _ in range(population_size):
        solution = {}
        for item in goods:
            if item in prices_x and item in prices_y:
                source = random.choice(['X', 'Y'])
            elif item in prices_x:
                source = 'X'
            else:
                source = 'Y'
            quantity = random.randint(1, 5)
            solution[item] = (source, quantity)
        population.append(solution)
    return population

# 选择父代
def select_parents(population):
    population.sort(key=calculate_cost)
    return population[:population_size // 2]  # 选择适应度最高的一半

# 交叉操作
def crossover(parent1, parent2):
    child = {}
    for item in goods:
        if random.random() > 0.5:
            child[item] = parent1[item]
        else:
            child[item] = parent2[item]
    return child

# 变异操作
def mutate(solution):
    if random.random() < mutation_rate:
        item = random.choice(goods)
        source = 'X' if solution[item][0] == 'Y' else 'Y'
        quantity = random.randint(1, 5)
        solution[item] = (source, quantity)
    return solution

# 主遗传算法流程
def genetic_algorithm():
    population = initialize_population()
    best_solution = None
    best_cost = float('inf')
    
    for generation in range(generations):
        new_population = []
        parents = select_parents(population)
        
        # 生成新一代
        while len(new_population) < population_size:
            parent1, parent2 = random.sample(parents, 2)
            child = crossover(parent1, parent2)
            child = mutate(child)
            new_population.append(child)
        
        # 更新种群和最佳方案
        population = new_population
        current_best = min(population, key=calculate_cost)
        current_cost = calculate_cost(current_best)
        
        if current_cost < best_cost:
            best_cost = current_cost
            best_solution = current_best
        
        print(f"Generation {generation + 1}: Best Cost = {best_cost}")
    
    return best_solution, best_cost

# 运行遗传算法并输出结果
best_solution, best_cost = genetic_algorithm()
print("最佳采购方案：", best_solution)
print("最低成本：", best_cost)

代码解读

1. 数据定义：首先定义了物资种类及其在供应商X和供应商Y的价格。

2. 适应度函数：calculate_cost计算采购方案的总成本，如果某方案超出供应商的数量限制，则将其适应度设置为无穷大以排除该方案。

3. 初始化种群：initialize_population生成随机的初始方案，确保每种物资至少采购一个单位，并随机分配供应商。

4. 选择父代：select_parents按适应度排序后选择适应度高的方案作为父代。

5. 交叉和变异：在crossover函数中实现了父代交叉，mutate函数则对生成的方案进行随机变异。

6. 遗传算法主循环：genetic_algorithm控制整个算法流程，包括生成新一代、更新最佳方案以及输出结果。

运行与结果

运行以上代码，遗传算法将经过设定的代数（200代）进行优化，最终输出一个最优的采购方案和最低的采购成本。每一代的最佳成本都会显示在控制台上，帮助观察优化过程。