用遗传算法写一个矩形排样算法

好的，下面是一个简单的矩形排样遗传算法的示例代码（使用Python实现）：

import random

# 定义矩形类
class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

# 定义个体类
class Individual:
    def __init__(self, rects):
        self.rects = rects
        self.fitness = 0

# 定义遗传算法类
class GeneticAlgorithm:
    def __init__(self, rects, pop_size, mutation_rate, generations):
        self.rects = rects
        self.pop_size = pop_size
        self.mutation_rate = mutation_rate
        self.generations = generations
        self.population = []
        self.best_individual = None

    # 初始化种群
    def init_population(self):
        for i in range(self.pop_size):
            rects = self.random_rects()
            individual = Individual(rects)
            self.population.append(individual)

    # 产生随机的矩形排样方案
    def random_rects(self):
        rects = []
        for rect in self.rects:
            if random.random() > 0.5:
                rects.append(Rectangle(rect.width, rect.height))
            else:
                rects.append(Rectangle(rect.height, rect.width))
        return rects

    # 计算个体的适应度
    def evaluate_fitness(self, individual):
        area_sum = 0
        for rect in individual.rects:
            area_sum += rect.width * rect.height
        width_sum = 0
        for rect in individual.rects:
            width_sum += rect.width
        height_max = max([rect.height for rect in individual.rects])
        fitness = area_sum / (width_sum * height_max)
        individual.fitness = fitness

    # 选择操作
    def select(self):
        population_size = len(self.population)
        fitnesses = [individual.fitness for individual in self.population]
        total_fitness = sum(fitnesses)
        probabilities = [fitness / total_fitness for fitness in fitnesses]
        selected = []
        for i in range(population_size):
            r = random.random()
            cumulative_probability = 0
            for j in range(population_size):
                cumulative_probability += probabilities[j]
                if r < cumulative_probability:
                    selected.append(self.population[j])
                    break
        return selected

    # 交叉操作
    def crossover(self, parent1, parent2):
        point = random.randint(1, len(parent1.rects) - 1)
        child1 = parent1.rects[:point] + parent2.rects[point:]
        child2 = parent2.rects[:point] + parent1.rects[point:]
        return Individual(child1), Individual(child2)

    # 变异操作
    def mutate(self, individual):
        for i in range(len(individual.rects)):
            if random.random() < self.mutation_rate:
                individual.rects[i] = Rectangle(individual.rects[i].height, individual.rects[i].width)

    # 进化操作
    def evolve(self):
        self.init_population()
        for generation in range(self.generations):
            for individual in self.population:
                self.evaluate_fitness(individual)
            self.population.sort(key=lambda individual: individual.fitness, reverse=True)
            if not self.best_individual or self.best_individual.fitness < self.population[0].fitness:
                self.best_individual = self.population[0]
            selected = self.select()
            next_population = []
            for i in range(self.pop_size // 2):
                parent1 = random.choice(selected)
                parent2 = random.choice(selected)
                child1, child2 = self.crossover(parent1, parent2)
                self.mutate(child1)
                self.mutate(child2)
                next_population.append(child1)
                next_population.append(child2)
            self.population = next_population

        return self.best_individual.rects

使用示例：

# 定义矩形
rects = [Rectangle(3, 4), Rectangle(2, 5), Rectangle(6, 2), Rectangle(1, 1)]

# 定义遗传算法对象
ga = GeneticAlgorithm(rects, pop_size=10, mutation_rate=0.1, generations=50)

# 进化
best_rects = ga.evolve()

# 输出排样方案
for rect in best_rects:
    print(rect.width, rect.height)

以上是一个简单的矩形排样遗传算法的实现，可以根据需要进行修改和优化。