用python写一段遗传算法代码 ： 供需匹配问题的遗传算法求解代码

以下是一个简单的遗传算法求解供需匹配问题的代码示例：

import random

class Gene:
    def __init__(self, supply, demand):
        self.supply = supply
        self.demand = demand
        self.match = [0] * len(demand)
    
    def fitness(self):
        return sum([self.match[i] for i in range(len(self.demand))])

class GA:
    def __init__(self, genes, pop_size, elite_size, mutation_rate, num_generations):
        self.genes = genes
        self.pop_size = pop_size
        self.elite_size = elite_size
        self.mutation_rate = mutation_rate
        self.num_generations = num_generations

    def crossover(self, gene1, gene2):
        child = Gene(gene1.supply, gene1.demand)
        crossover_point = random.randint(1, len(child.match) - 1)
        child.match = gene1.match[:crossover_point] + gene2.match[crossover_point:]
        return child

    def mutate(self, gene):
        for i in range(len(gene.match)):
            if random.uniform(0, 1) < self.mutation_rate:
                gene.match[i] = 1 - gene.match[i]

    def select_elite(self, population):
        return sorted(population, key=lambda gene: gene.fitness(), reverse=True)[:self.elite_size]

    def select_parent(self, population):
        fitness_sum = sum([gene.fitness() for gene in population])
        r = random.uniform(0, fitness_sum)
        for gene in population:
            r -= gene.fitness()
            if r <= 0:
                return gene

    def evolve(self):
        population = [Gene(gene.supply, gene.demand) for gene in self.genes] * self.pop_size
        for i in range(self.num_generations):
            elite = self.select_elite(population)
            offspring = []
            while len(offspring) < self.pop_size - self.elite_size:
                parent1 = self.select_parent(population)
                parent2 = self.select_parent(population)
                child = self.crossover(parent1, parent2)
                self.mutate(child)
                offspring.append(child)
            population = elite + offspring
        return max(population, key=lambda gene: gene.fitness())

if __name__ == '__main__':
    supply = [10, 20, 30]
    demand = [15, 15, 15]
    genes = [Gene(supply, demand) for i in range(10)]
    ga = GA(genes, pop_size=100, elite_size=20, mutation_rate=0.1, num_generations=100)
    solution = ga.evolve()
    print("Matching: ", solution.match)

在以上代码中，我们定义了Gene类来代表一个基因，其中supply表示供应列表，demand表示需求列表，match表示匹配矩阵，每个元素为0或1，表示该供应是否分配给该需求。Gene类还有一个fitness方法，用来计算匹配矩阵的适应度，即满足需求的数量。

然后我们定义了GA类来实现遗传算法，其中包含了交叉、变异、精英选择、轮盘赌选择等操作。在evolve方法中，我们将种群初始化为若干个基因的拷贝，然后在每一代中进行精英选择、交叉、变异等操作，得到下一代种群。

在主函数中，我们定义了供需列表，生成了若干个基因，然后创建了GA对象并运行evolve方法，得到最终的匹配结果。

需要注意的是，这个示例实现的是一个简化的供需匹配问题，只有三个供应和三个需求。如果需要求解更复杂的问题，需要根据具体情况修改代码。