c# 二维下料优化排版 遗传算法代码

以下是一个简单的C#二维下料优化排版遗传算法的代码示例：

using System;
using System.Collections.Generic;

namespace TwoDimensionalCuttingProblem
{
    class Program
    {
        static void Main(string[] args)
        {
            // 初始材料大小
            int width = 800;
            int height = 600;

            // 初始零件列表
            List<Part> parts = new List<Part>();
            parts.Add(new Part(200, 100));
            parts.Add(new Part(300, 100));
            parts.Add(new Part(150, 150));
            parts.Add(new Part(250, 200));

            // 遗传算法参数
            int populationSize = 20;
            int generationCount = 1000;
            double mutationRate = 0.1;
            double crossoverRate = 0.8;

            // 初始化遗传算法
            GeneticAlgorithm ga = new GeneticAlgorithm(width, height, parts, populationSize, mutationRate, crossoverRate);

            // 进行遗传算法优化
            for (int i = 0; i < generationCount; i++)
            {
                ga.Evolve();
                Console.WriteLine("Generation {0}: Best Fit = {1}", i + 1, ga.BestIndividual.Fitness);
            }

            // 输出最优结果
            Console.WriteLine("\nBest Solution:");
            Console.WriteLine(ga.BestIndividual.ToString());
        }
    }

    // 表示一个零件
    class Part
    {
        public int Width { get; set; }
        public int Height { get; set; }

        public Part(int width, int height)
        {
            Width = width;
            Height = height;
        }
    }

    // 表示一个布局方案
    class Layout
    {
        public int Width { get; set; }
        public int Height { get; set; }
        public List<Part> Parts { get; set; }

        public Layout(int width, int height, List<Part> parts)
        {
            Width = width;
            Height = height;
            Parts = parts;
        }

        // 计算布局方案的适应度
        public double Fitness
        {
            get
            {
                double fitness = 0;
                foreach (Part part in Parts)
                {
                    if (part.X + part.Width > Width || part.Y + part.Height > Height)
                    {
                        fitness -= 1000000; // 超出材料范围，适应度大幅降低
                    }
                    else
                    {
                        fitness += part.Width * part.Height;
                    }
                }
                return fitness;
            }
        }

        public override string ToString()
        {
            string str = string.Format("Layout ({0} x {1}):", Width, Height);
            foreach (Part part in Parts)
            {
                str += string.Format("\n({0}, {1}, {2}, {3})", part.X, part.Y, part.Width, part.Height);
            }
            return str;
        }
    }

    // 表示一个布局方案的个体
    class Individual
    {
        public Layout Layout { get; set; }
        public double Fitness { get; set; }

        public Individual(Layout layout)
        {
            Layout = layout;
            Fitness = layout.Fitness;
        }

        public override string ToString()
        {
            return Layout.ToString();
        }
    }

    // 遗传算法
    class GeneticAlgorithm
    {
        private int Width { get; set; }
        private int Height { get; set; }
        private List<Part> Parts { get; set; }
        private int PopulationSize { get; set; }
        private double MutationRate { get; set; }
        private double CrossoverRate { get; set; }
        private List<Individual> Population { get; set; }
        public Individual BestIndividual { get; set; }

        public GeneticAlgorithm(int width, int height, List<Part> parts, int populationSize, double mutationRate, double crossoverRate)
        {
            Width = width;
            Height = height;
            Parts = parts;
            PopulationSize = populationSize;
            MutationRate = mutationRate;
            CrossoverRate = crossoverRate;

            // 初始化种群
            Population = new List<Individual>();
            for (int i = 0; i < PopulationSize; i++)
            {
                Layout layout = RandomLayout();
                Population.Add(new Individual(layout));
            }

            // 计算初始最优解
            BestIndividual = Population[0];
            foreach (Individual individual in Population)
            {
                if (individual.Fitness > BestIndividual.Fitness)
                {
                    BestIndividual = individual;
                }
            }
        }

        // 随机生成一个布局方案
        private Layout RandomLayout()
        {
            List<Part> parts = new List<Part>();
            foreach (Part part in Parts)
            {
                parts.Add(new Part(part.Width, part.Height));
            }

            Random rand = new Random();
            foreach (Part part in parts)
            {
                part.X = rand.Next(Width - part.Width);
                part.Y = rand.Next(Height - part.Height);
            }

            return new Layout(Width, Height, parts);
        }

        // 进化种群
        public void Evolve()
        {
            // 选择
            List<Individual> newPopulation = new List<Individual>();
            for (int i = 0; i < PopulationSize; i++)
            {
                Individual parent1 = Selection();
                Individual parent2 = Selection();

                // 交叉
                Individual child = Crossover(parent1, parent2);

                // 变异
                Mutate(child);

                newPopulation.Add(child);
            }
            Population = newPopulation;

            // 计算适应度
            foreach (Individual individual in Population)
            {
                individual.Fitness = individual.Layout.Fitness;
            }

            // 更新最优解
            foreach (Individual individual in Population)
            {
                if (individual.Fitness > BestIndividual.Fitness)
                {
                    BestIndividual = individual;
                }
            }
        }

        // 选择操作
        private Individual Selection()
        {
            List<Individual> tournament = new List<Individual>();
            Random rand = new Random();
            for (int i = 0; i < 5; i++)
            {
                tournament.Add(Population[rand.Next(PopulationSize)]);
            }

            Individual bestIndividual = tournament[0];
            foreach (Individual individual in tournament)
            {
                if (individual.Fitness > bestIndividual.Fitness)
                {
                    bestIndividual = individual;
                }
            }

            return bestIndividual;
        }

        // 交叉操作
        private Individual Crossover(Individual parent1, Individual parent2)
        {
            Random rand = new Random();
            if (rand.NextDouble() < CrossoverRate)
            {
                List<Part> childParts = new List<Part>();
                foreach (Part part in Parts)
                {
                    int x = Math.Max(parent1.Layout.Parts[Parts.IndexOf(part)].X, parent2.Layout.Parts[Parts.IndexOf(part)].X);
                    int y = Math.Max(parent1.Layout.Parts[Parts.IndexOf(part)].Y, parent2.Layout.Parts[Parts.IndexOf(part)].Y);
                    childParts.Add(new Part(part.Width, part.Height) { X = x, Y = y });
                }

                return new Individual(new Layout(Width, Height, childParts));
            }
            else
            {
                return parent1;
            }
        }

        // 变异操作
        private void Mutate(Individual individual)
        {
            Random rand = new Random();
            if (rand.NextDouble() < MutationRate)
            {
                List<Part> mutatedParts = new List<Part>();
                foreach (Part part in Parts)
                {
                    Part mutatedPart = new Part(part.Width, part.Height) { X = part.X, Y = part.Y };
                    if (rand.NextDouble() < 0.5)
                    {
                        mutatedPart.X = rand.Next(Width - part.Width);
                    }
                    else
                    {
                        mutatedPart.Y = rand.Next(Height - part.Height);
                    }
                    mutatedParts.Add(mutatedPart);
                }
                individual.Layout = new Layout(Width, Height, mutatedParts);
            }
        }
    }
}

在这个代码示例中，我们使用了遗传算法来优化二维下料的布局方案。具体来说，我们将每个零件看作是一个矩形，然后将这些矩形排列在一个大矩形（即材料）中，使得它们不会相互重叠或超出材料范围。我们使用遗传算法来搜索最优的排列方案。

在这个代码示例中，我们定义了三个类：`Part` 表示一个零件，`Layout` 表示一个布局方案，`Individual` 表示一个布局方案的个体。我们还定义了一个 `GeneticAlgorithm` 类来实现遗传算法。

在 `GeneticAlgorithm` 类中，我们使用了一些常见的遗传算法操作。具体来说，我们通过 `Selection` 方法来选择父代个体，通过 `Crossover` 方法来交叉两个父代个体生成子代个体，通过 `Mutate` 方法来对子代个体进行变异，通过 `Evolve` 方法来进化整个种群。我们还定义了一个 `BestIndividual` 属性来记录当前最优的布局方案。

在 `Layout` 类中，我们定义了一个 `Fitness` 属性来计算布局方案的适应度。具体来说，我们将每个零件的面积作为适应度的一部分，但是如果某个零件超出了材料范围，则将适应度大幅降低。

在 `Main` 方法中，我们使用了以上定义的类来实现二维下料的优化排版。我们首先定义了一个初始的材料大小和零件列表，然后定义了遗传算法的参数。接着，我们初始化遗传算法，然后进行遗传算法的优化，最终输出最优结果。

请注意，这个代码示例只是一个简单的实现，并不一定是最优的。您可以根据实际情况对其进行修改和改进。