C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Collections.Generic;

public class Program
{
	public static Random rand=new Random();								//global class Random
	
	//class point
	
	public class Point
	{																
		public int ID {get;set;}										//properties									
		public int X {get;set;}										
		public int Y {get;set;}
		
		
		public Point (int id, int x, int y)								//constructor
		{
			ID=id;
			X=x;
			Y=y;	
		}
		
		public double DistanceToPoint (Point p)																			//calculate and return the distance to a given point
		{
			return Math.Sqrt(Math.Pow((X - p.X), 2)+ Math.Pow((Y - p.Y), 2));												//formula from IOT 1																											
		}	
	}

	//class filehandler
	
	public class FileHandler
	{
		const string file = ("NAME : att48 COMMENT : 48 capitals of the US (Padberg/Rinaldi) TYPE : TSP DIMENSION : 48 EDGE_WEIGHT_TYPE : ATT NODE_COORD_SECTION 1 6734 1453 2 2233 10 3 5530 1424 4 401 841 5 3082 1644 6 7608 4458 7 7573 3716 8 7265 1268 9 6898 1885 10 1112 2049 11 5468 2606 12 5989 2873 13 4706 2674 14 4612 2035 15 6347 2683 16 6107 669 17 7611 5184 18 7462 3590 19 7732 4723 20 5900 3561 21 4483 3369 22 6101 1110 23 5199 2182 24 1633 2809 25 4307 2322 26 675 1006 27 7555 4819 28 7541 3981 29 3177 756 30 7352 4506 31 7545 2801 32 3245 3305 33 6426 3173 34 4608 1198 35 23 2216 36 7248 3779 37 7762 4595 38 7392 2244 39 3484 2829 40 6271 2135 41 4985 140 42 1916 1569 43 7280 4899 44 7509 3239 45 10 2676 46 6807 2993 47 5185 3258 48 3023 1942 EOF");	
		public string [] parts = file.Split();															//to process the data in an easier way
		public List <Point> pointlist= new List <Point> ();												//return value at ReadPoints
		
	
		public List<Point> ReadPoints()
		{
			int i = 21;										//ignore the first 21 (from 0 to 20) indices of the parts array, since there is stored unnecessary information
			Point x = new Point(0,0,0);						//at index 0 of the pointlist we have node 0, which we never use, but it is easier to handle the list afterwards
			pointlist.Add(x);
				while ( i < parts.Length-1)																												//-1 because of EOF; go through all points															
				{
					Point p = new Point (Convert.ToInt32(parts[i]), Convert.ToInt32(parts[i+1]), Convert.ToInt32(parts[i+2]));							//create an object of the class point
					pointlist.Add(p);																													//add the point to the pointlist
		 			i+=3;																																//go to the next point
				}
			/*for(int y=0; y<pointlist.Count; y++)			//testing (printing the pointlist)
			{
				Console.WriteLine("id: " + pointlist[y].ID + " , x: " + pointlist[y].X + " , y: " + pointlist[y].Y);
				
			}*/
			return pointlist;
		}
		
	}
	//class Tour
	
	public class ResultingTour
	{
		public double DistanceOfTheTour {get;set;} 																		//properties
		public List<int> Tour;
		public List<Point> OriginalListOfPoints;																		
		
		public void CalculateCosts()
		{
			DistanceOfTheTour=0;
			for(int i=0; i<Tour.Count-1; i++)
			{
					DistanceOfTheTour+=OriginalListOfPoints[Tour[i]].DistanceToPoint(OriginalListOfPoints[Tour[i+1]]);
			}
		}
		
		public ResultingTour (List <int> tour, List<Point> originalListOfPoints)										//constructor with two properties
		{
			Tour=tour;
			OriginalListOfPoints=originalListOfPoints;
			DistanceOfTheTour=0;
			for(int i=0; i<Tour.Count-1; i++)
			{
					DistanceOfTheTour+=OriginalListOfPoints[Tour[i]].DistanceToPoint(OriginalListOfPoints[Tour[i+1]]);
					//Console.WriteLine("i: " + Tour[i] + " j: " + Tour[i+1] + " distance: " + DistanceOfTheTour);				//testing (if distance is computed the right way)
			}
		}
		
		public ResultingTour ()																							//empty constuctor
		{}
		
		public ResultingTour (ResultingTour tour)																		//constructor with one property
		{
		 	Tour=tour.Tour;
			OriginalListOfPoints=tour.OriginalListOfPoints;
			DistanceOfTheTour=tour.DistanceOfTheTour;
		}
	}
		
	//initialization - create random tours	
	
	public ResultingTour InitialTourGeneration (List <Point> pointlist)
	{
		
	    List<int> tour = new List<int>();
																						
		List<int> pointsToStillInsert = new List<int>();								//1. generate a List<int> with all IDs
		for(int i=1; i<pointlist.Count; i++)
			pointsToStillInsert.Add(pointlist[i].ID);									//2. if the list is not empty
		
		while(pointsToStillInsert.Count>0)
		{
																							//2.1 draw a point from the list
			int r = rand.Next(pointsToStillInsert.Count);										
			int indexOfPointToInsert = r; 	
			int pointToInsert = pointsToStillInsert[indexOfPointToInsert]; 					
			tour.Add(pointToInsert);															//2.2 add the point to the tour 
																						
			pointsToStillInsert.RemoveAt(indexOfPointToInsert); 								//2.3 delete the point from the list
			
		}
		
		tour.Add(tour[0]);																		//close the tour to the starting point	
			
		/*for(int y=0; y<tour.Count; y++)														//testing (printing the initial tours)
			{
				Console.WriteLine(tour[y]);
				
			}
		Console.WriteLine();*/
		
		ResultingTour resultingTour = new ResultingTour(tour, pointlist);
		
		//Console.WriteLine(resultingTour.DistanceOfTheTour);									//testing (printing the distances of the initial tours)

		return resultingTour;															//3. return an object of the class ResultingTour
	}
	
	//fitness evaluation																	//fitness is the distance of a tour (the smaller the distance the better)
	
	public List<double> FitnessEvaluation(List<ResultingTour> population)		
	{
		List<double> weightedDistance= new List<double>();
		double maxDistance=0;
		for(int i=0; i<population.Count; i++)
		{
			if(population[i].DistanceOfTheTour>maxDistance)
			{
				maxDistance=population[i].DistanceOfTheTour;
			}
		}

		
		double fitnessSum=0;																		//fitness total (not weighted)
		for(int i=0; i<population.Count; i++)
		{
			fitnessSum+=maxDistance-population[i].DistanceOfTheTour;
			//Console.WriteLine("i: " + i + " " + fitnessSum);										//testing (print if the computation of the fitnessSum works well)
		}
		
		List<double> fitnessList = new List <double>();												//fitness list for weighted fitness
		//double xyz=0;	
		
		for(int i=0; i<population.Count; i++)													
		{ 
			//y= größtes x - aktuelles x
			fitnessList.Add(((maxDistance-population[i].DistanceOfTheTour)/fitnessSum));				
			//xyz+=(((maxDistance-population[i].DistanceOfTheTour)/fitnessSum));
			//Console.WriteLine("i: " + i + " " + fitnessList[i]);									//testing (print the fitnessList)
			//Console.WriteLine("i: " + i + " " + population[i].DistanceOfTheTour/fitnessSum);
			//Console.WriteLine("i: " + i + " " + xyz);
		}
		return fitnessList;
	}
	
	//selection
	
	public ResultingTour SelectParent(List<ResultingTour> population, List<double> fitnessList)
	{
		double partialSum=0;
		double n = rand.NextDouble();														//generates random number between 0 and 1
		//Console.WriteLine("random number: " + n);
		for(int i=0; i<population.Count; i++)
		{
			partialSum+=fitnessList[i];
			if(partialSum>n)
				return population[i];
		}
		return population[population.Count-1];																		//für was brauch ich das? wenn es keinen parent gibt der größer n ist?
	}	
	
	//crossover																				
	
	public ResultingTour Crossover(ResultingTour parentA, ResultingTour parentB, List<Point> originalpointlist)
	{
		List<int> tour= new List<int>();
		ResultingTour child = new ResultingTour(tour, originalpointlist);
		
		/*Console.WriteLine("parentA: ");
		for(int y=0; y<parentA.Tour.Count; y++)														//testing (printing the initial tours)
			{
				Console.WriteLine(parentA.Tour[y]);
				
			}
		Console.WriteLine("parentB: ");
		for(int y=0; y<parentB.Tour.Count; y++)														//testing (printing the initial tours)
			{
				Console.WriteLine(parentB.Tour[y]);
				
			}*/
		
		int c=0;																			//cutting point at parent 1; cut before this point
		c = rand.Next(1,parentA.Tour.Count-1);												//determine the cutting point randomly
		
		for(int i=0; i<c; i++)
		{
			//Console.WriteLine("parentA: " + parentA.Tour[i]);
			child.Tour.Insert(i,parentA.Tour[i]);													//child gets the first part from parent A until the cutting point
			//Console.WriteLine("child: " + child.Tour[i]);
		}
		
			int counter=0;
			int counterMax=(parentA.Tour.Count-1)-c;									//so viele Stellen müssen im child noch befüllt werden
		
			for(int p=c; p<parentB.Tour.Count; p++)										//in parent B alle ab cutting point durchgehen	
			{																					
				bool alreadyInTheChild=false;
				for(int y=0; y<c; y++)														//in child alle die schon drinnen sind durchgehen
				{
					if(parentB.Tour[p]==child.Tour[y])										//wenn element von parent B an der leeren Stelle schon in child ist
					{
						alreadyInTheChild=true;												//dann kann man zum nächsten element in parent B gehen
						y=c;
					}
				}
				
				if(alreadyInTheChild==false)											//if the element is not in the child 
				{
					child.Tour.Insert(c+counter,parentB.Tour[p]);										//then put the element into the child
					counter+=1;
				}
			}
			if(counter<counterMax)														//wenn noch nicht alle leeren indizes im child voll sind dann muss man am anfang von parent B weitermachen
			{
				for(int p=1; p<c; p++)										//in parent B alle ab cutting point durchgehen
				{																					
					bool alreadyInTheChild=false;
					for(int y=0; y<c; y++)														//in child alle die schon drinnen sind durchgehen
					{
						if(parentB.Tour[p]==child.Tour[y])										//wenn element von parent B an der leeren Stelle schon in child ist
						{
							alreadyInTheChild=true;												//dann kann man zum nächsten element in parent B gehen
							y=c;
						}
					}
					
					if(alreadyInTheChild==false)											//wenn element noch nicht in child ist
					{
						child.Tour.Insert(c+counter,parentB.Tour[p]);										//dann einfügen
						counter+=1;
					}
				}	
			}
			child.Tour.Add(child.Tour[0]);												//das letzte element in child muss gleich dem ersten sein(--> tour schließen)
			child.CalculateCosts();
			return child;
	
	}
	
		
	//mutation
	
	public ResultingTour Mutation (ResultingTour tour)
	{
		bool alreadyMutated=false;
		//Console.WriteLine(tour.DistanceOfTheTour);
		/*Console.WriteLine("tour before mutation: ");
		for(int y=0; y<tour.Tour.Count; y++)					//testing (printing tour before mutation)
			{
				Console.WriteLine(tour.Tour[y]);
			}
		Console.WriteLine();*/
		
		while(alreadyMutated==false)
		{
			//Console.WriteLine(tour.Tour.Count);
			int a = rand.Next(1,tour.Tour.Count-1);				//startnode/endnode must not be selected for swaping, because the startnode/endnode would maybe not be the same anymore
			int b = rand.Next(a+1,tour.Tour.Count-1);			//determine random indices of points which will be swapped
			//Console.WriteLine("a: " + a);
			//Console.WriteLine("b: " + b);
			
			if(a!=b)											//if a and b are different then swap (if a would be equal to b a swap wouldn't make any sense)
			{
				int temp = tour.Tour[a];
				//Console.WriteLine(tour.Tour[a]);				//testing
   				tour.Tour[a] = tour.Tour[b];
				//Console.WriteLine(tour.Tour[a]);				//testing
    			tour.Tour[b] = temp;
				alreadyMutated=true;							 
			}
		}
		
		/*Console.WriteLine("tour after mutation: ");
		for(int y=0; y<tour.Tour.Count; y++)					//testing (printing tour after mutation)
			{
				Console.WriteLine(tour.Tour[y]);
				
			}*/
		
		tour.CalculateCosts();
		//Console.WriteLine(tour.DistanceOfTheTour);
		return tour;
	}
	
	//alternative mutation operator
	
	public ResultingTour MutationAlternative (ResultingTour tour)
	{
		/*for(int y=0; y<tour.Tour.Count; y++)														//testing (printing tour before mutation)
			{
				Console.WriteLine("index: " + y + " - " + tour.Tour[y]);
			}*/
		bool alreadyMutated=false;
		
		while(alreadyMutated==false)
		{
			int a = rand.Next(1,tour.Tour.Count-1);				//startnode und endnode dürfen nicht zu tauschen ausgewählt werden, weil sonst ist der startnode nicht mehr gleich dem endnode
			int b = rand.Next(1,tour.Tour.Count-1);				//determine random indices of points in between which we will change the sequence of the points
			/*Console.WriteLine("index a: " + a);
			Console.WriteLine("index b: " + b);
			Console.WriteLine("a: " + tour.Tour[a]);
			Console.WriteLine("b: " + tour.Tour[b]);*/
		
			if(a!=b)											//if a and b are different then swap (if a would be equal to b a swap wouldn't make any sense)
			{
				if(a>b)
				{
					tour.Tour.Reverse(b,a-b+1);	
				}
				if(a<b)
				{
					tour.Tour.Reverse(a,b-a+1);
				}
				alreadyMutated=true;
			}
		
			/*for(int y=0; y<tour.Tour.Count; y++)														//testing (printing tour after mutation)
				{
					Console.WriteLine("index: " + y + " - " + tour.Tour[y]);
				}*/
		}	
		tour.CalculateCosts();
		return tour;
	}
		
	//method genetic algorithm
	
	public List <ResultingTour> GeneticAlgorithm (List <Point> pointlist, double mutationRate)
	{
		List <ResultingTour> population = new List <ResultingTour>();
		int populationSize=100;
		int numberOfGenerations=50;
			
		for(int d=0; d<populationSize; d++)																		//create initial population
		{
			ResultingTour resultingTour=InitialTourGeneration(pointlist);
			population.Add(resultingTour);
			//Console.WriteLine("distance of tour " + d + " : " + population[d].DistanceOfTheTour);				//testing (printing the distances of all the 100 initial tours)
		}
		

		for(int g=0; g<numberOfGenerations; g++)																//generate new generations
		{	
			List <ResultingTour> newPopulation = new List <ResultingTour>();
			//Console.WriteLine("population: " + population.Count + " , new population: " + newPopulation.Count);
			List<double> fitnessList=FitnessEvaluation(population);
			
			double maxFitnessValue=0;
			int indexOfMaxFitnessValue=-1;
			
			/*for(int i=0; i<fitnessList.Count; i++)
			{
				Console.WriteLine(fitnessList[i] + " \t" + population[i].DistanceOfTheTour);
			}*/
			
			for(int i=0; i<population.Count; i++)
			{
				if(fitnessList[i]>maxFitnessValue)
				{
					maxFitnessValue=fitnessList[i];
					indexOfMaxFitnessValue=i;
				}
			}
			
			//Console.WriteLine("tour: " + indexOfMaxFitnessValue + " distance: " + population[indexOfMaxFitnessValue].DistanceOfTheTour);			//testing (the best tour of the population gets saved in the next population)
			newPopulation.Add(new ResultingTour(population[indexOfMaxFitnessValue]));
			
			int maxMutations=(int)(populationSize*mutationRate);
			for(int i =0; i<maxMutations; i++)
			{
				//Console.WriteLine("i: " + i);
				ResultingTour newTour=Mutation(SelectParent(population,fitnessList));
				//Console.WriteLine(newTour.DistanceOfTheTour);
				newPopulation.Add(newTour);
			}
			
			for(int i=0; i<populationSize-maxMutations-1; i++)
			{
				ResultingTour newTour=Crossover(SelectParent(population,fitnessList),SelectParent(population,fitnessList), pointlist);
				newPopulation.Add(newTour);
			}
			population=newPopulation;
			//Console.WriteLine("best of the generation: " + population[indexOfMaxFitnessValue].DistanceOfTheTour);
			//Console.WriteLine("population: " + population.Count + " , new population: " + newPopulation.Count);
		}
		return population;
	}
		

	public static void Main()
	{
		Program p=new Program();
		FileHandler fl=new FileHandler();
		List <Point> pointlist = fl.ReadPoints();
		List <ResultingTour> population=p.GeneticAlgorithm(pointlist, 0.2);
		
		List<double> fitnessList= p.FitnessEvaluation(population);
		
		double maxFitnessValue=0;
		int indexOfMaxFitnessValue=-1;
			for(int i=0; i<population.Count; i++)
			{
				if(fitnessList[i]>maxFitnessValue)
				{
					maxFitnessValue=fitnessList[i];
					indexOfMaxFitnessValue=i;
				}
			}
		
		Console.WriteLine("The best tour after generating 50 generations is tour:" + indexOfMaxFitnessValue);
		for(int y=0; y<population[indexOfMaxFitnessValue].Tour.Count; y++)														
			{
				Console.Write(population[indexOfMaxFitnessValue].Tour[y] + " ");
			}
		Console.WriteLine();
		Console.WriteLine("the corresponding distance is: " + population[indexOfMaxFitnessValue].DistanceOfTheTour);
		
		p.MutationAlternative (population[2]);
	}
}

​x
 
using System;
using System.Collections.Generic;
​
public class Program
{
    public static Random rand=new Random();                             //global class Random
    
    //class point
    
    public class Point
    {                                                               
        public int ID {get;set;}                                        //properties                                    
        public int X {get;set;}                                     
        public int Y {get;set;}
        
        
        public Point (int id, int x, int y)                             //constructor
        {
            ID=id;
            X=x;
            Y=y;    
        }
        
        public double DistanceToPoint (Point p)                                                                         //calculate and return the distance to a given point
        {
            return Math.Sqrt(Math.Pow((X - p.X), 2)+ Math.Pow((Y - p.Y), 2));                                               //formula from IOT 1                                                                                                            
        }   
    }
​
    //class filehandler
    
    public class FileHandler
    {
        const string file = ("NAME : att48 COMMENT : 48 capitals of the US (Padberg/Rinaldi) TYPE : TSP DIMENSION : 48 EDGE_WEIGHT_TYPE : ATT NODE_COORD_SECTION 1 6734 1453 2 2233 10 3 5530 1424 4 401 841 5 3082 1644 6 7608 4458 7 7573 3716 8 7265 1268 9 6898 1885 10 1112 2049 11 5468 2606 12 5989 2873 13 4706 2674 14 4612 2035 15 6347 2683 16 6107 669 17 7611 5184 18 7462 3590 19 7732 4723 20 5900 3561 21 4483 3369 22 6101 1110 23 5199 2182 24 1633 2809 25 4307 2322 26 675 1006 27 7555 4819 28 7541 3981 29 3177 756 30 7352 4506 31 7545 2801 32 3245 3305 33 6426 3173 34 4608 1198 35 23 2216 36 7248 3779 37 7762 4595 38 7392 2244 39 3484 2829 40 6271 2135 41 4985 140 42 1916 1569 43 7280 4899 44 7509 3239 45 10 2676 46 6807 2993 47 5185 3258 48 3023 1942 EOF");  
        public string [] parts = file.Split();                                                          //to process the data in an easier way
        public List <Point> pointlist= new List <Point> ();                                             //return value at ReadPoints
        
    
        public List<Point> ReadPoints()
        {
            int i = 21;                                     //ignore the first 21 (from 0 to 20) indices of the parts array, since there is stored unnecessary information
            Point x = new Point(0,0,0);                     //at index 0 of the pointlist we have node 0, which we never use, but it is easier to handle the list afterwards
            pointlist.Add(x);
                while ( i < parts.Length-1)                                                                                                             //-1 because of EOF; go through all points                                                          
                {
                    Point p = new Point (Convert.ToInt32(parts[i]), Convert.ToInt32(parts[i+1]), Convert.ToInt32(parts[i+2]));                          //create an object of the class point
                    pointlist.Add(p);                                                                                                                   //add the point to the pointlist
                    i+=3;                                                                                                                               //go to the next point
                }
            /*for(int y=0; y<pointlist.Count; y++)          //testing (printing the pointlist)
            {
                Console.WriteLine("id: " + pointlist[y].ID + " , x: " + pointlist[y].X + " , y: " + pointlist[y].Y);
                
            }*/
            return pointlist;
        }
        
    }
    //class Tour
    
    public class ResultingTour
    {
        public double DistanceOfTheTour {get;set;}                                                                      //properties
        public List<int> Tour;
        public List<Point> OriginalListOfPoints;                                                                        
        
        public void CalculateCosts()
        {
            DistanceOfTheTour=0;
            for(int i=0; i<Tour.Count-1; i++)
            {
                    DistanceOfTheTour+=OriginalListOfPoints[Tour[i]].DistanceToPoint(OriginalListOfPoints[Tour[i+1]]);
            }
        }
        
        public ResultingTour (List <int> tour, List<Point> originalListOfPoints)                                        //constructor with two properties
        {
            Tour=tour;
            OriginalListOfPoints=originalListOfPoints;
            DistanceOfTheTour=0;
            for(int i=0; i<Tour.Count-1; i++)
            {
                    DistanceOfTheTour+=OriginalListOfPoints[Tour[i]].DistanceToPoint(OriginalListOfPoints[Tour[i+1]]);
                    //Console.WriteLine("i: " + Tour[i] + " j: " + Tour[i+1] + " distance: " + DistanceOfTheTour);              //testing (if distance is computed the right way)
            }
        }
        
        public ResultingTour ()                                                                                         //empty constuctor
        {}
        
        public ResultingTour (ResultingTour tour)                                                                       //constructor with one property
        {
            Tour=tour.Tour;
            OriginalListOfPoints=tour.OriginalListOfPoints;
            DistanceOfTheTour=tour.DistanceOfTheTour;
        }
    }
        
    //initialization - create random tours  
    
    public ResultingTour InitialTourGeneration (List <Point> pointlist)
    {
        
        List<int> tour = new List<int>();
                                                                                        
        List<int> pointsToStillInsert = new List<int>();                                //1. generate a List<int> with all IDs
        for(int i=1; i<pointlist.Count; i++)
            pointsToStillInsert.Add(pointlist[i].ID);                                   //2. if the list is not empty
        
        while(pointsToStillInsert.Count>0)
        {
                                                                                            //2.1 draw a point from the list
            int r = rand.Next(pointsToStillInsert.Count);                                       
            int indexOfPointToInsert = r;   
            int pointToInsert = pointsToStillInsert[indexOfPointToInsert];                  
            tour.Add(pointToInsert);                                                            //2.2 add the point to the tour 
                                                                                        
            pointsToStillInsert.RemoveAt(indexOfPointToInsert);                                 //2.3 delete the point from the list
            
        }
        
        tour.Add(tour[0]);                                                                      //close the tour to the starting point  
            
        /*for(int y=0; y<tour.Count; y++)                                                       //testing (printing the initial tours)
            {
                Console.WriteLine(tour[y]);
                
            }
        Console.WriteLine();*/
        
        ResultingTour resultingTour = new ResultingTour(tour, pointlist);
        
        //Console.WriteLine(resultingTour.DistanceOfTheTour);                                   //testing (printing the distances of the initial tours)
​
        return resultingTour;                                                           //3. return an object of the class ResultingTour
    }
    
    //fitness evaluation                                                                    //fitness is the distance of a tour (the smaller the distance the better)
    
    public List<double> FitnessEvaluation(List<ResultingTour> population)       
    {
        List<double> weightedDistance= new List<double>();
        double maxDistance=0;
        for(int i=0; i<population.Count; i++)
        {
            if(population[i].DistanceOfTheTour>maxDistance)
            {
                maxDistance=population[i].DistanceOfTheTour;
            }
        }
​
        
        double fitnessSum=0;                                                                        //fitness total (not weighted)
        for(int i=0; i<population.Count; i++)
        {
            fitnessSum+=maxDistance-population[i].DistanceOfTheTour;
            //Console.WriteLine("i: " + i + " " + fitnessSum);                                      //testing (print if the computation of the fitnessSum works well)
        }
        
        List<double> fitnessList = new List <double>();                                             //fitness list for weighted fitness
        //double xyz=0; 
        
        for(int i=0; i<population.Count; i++)                                                   
        { 
            //y= größtes x - aktuelles x
            fitnessList.Add(((maxDistance-population[i].DistanceOfTheTour)/fitnessSum));                
            //xyz+=(((maxDistance-population[i].DistanceOfTheTour)/fitnessSum));
            //Console.WriteLine("i: " + i + " " + fitnessList[i]);                                  //testing (print the fitnessList)
            //Console.WriteLine("i: " + i + " " + population[i].DistanceOfTheTour/fitnessSum);
            //Console.WriteLine("i: " + i + " " + xyz);
        }
        return fitnessList;
    }
    
    //selection
    
    public ResultingTour SelectParent(List<ResultingTour> population, List<double> fitnessList)
    {
        double partialSum=0;
        double n = rand.NextDouble();                                                       //generates random number between 0 and 1
        //Console.WriteLine("random number: " + n);
        for(int i=0; i<population.Count; i++)
        {
            partialSum+=fitnessList[i];
            if(partialSum>n)
                return population[i];
        }
        return population[population.Count-1];                                                                      //für was brauch ich das? wenn es keinen parent gibt der größer n ist?
    }   
    
    //crossover                                                                             
    
    public ResultingTour Crossover(ResultingTour parentA, ResultingTour parentB, List<Point> originalpointlist)
    {
        List<int> tour= new List<int>();
        ResultingTour child = new ResultingTour(tour, originalpointlist);
        
        /*Console.WriteLine("parentA: ");
        for(int y=0; y<parentA.Tour.Count; y++)                                                     //testing (printing the initial tours)
            {
                Console.WriteLine(parentA.Tour[y]);
                
            }
        Console.WriteLine("parentB: ");
        for(int y=0; y<parentB.Tour.Count; y++)                                                     //testing (printing the initial tours)
            {
                Console.WriteLine(parentB.Tour[y]);
                
            }*/
        
        int c=0;                                                                            //cutting point at parent 1; cut before this point
        c = rand.Next(1,parentA.Tour.Count-1);                                              //determine the cutting point randomly
        
        for(int i=0; i<c; i++)
        {
            //Console.WriteLine("parentA: " + parentA.Tour[i]);
            child.Tour.Insert(i,parentA.Tour[i]);                                                   //child gets the first part from parent A until the cutting point
            //Console.WriteLine("child: " + child.Tour[i]);
        }
        
            int counter=0;
            int counterMax=(parentA.Tour.Count-1)-c;                                    //so viele Stellen müssen im child noch befüllt werden
        
            for(int p=c; p<parentB.Tour.Count; p++)                                     //in parent B alle ab cutting point durchgehen  
            {                                                                                   
                bool alreadyInTheChild=false;
                for(int y=0; y<c; y++)                                                      //in child alle die schon drinnen sind durchgehen
                {
                    if(parentB.Tour[p]==child.Tour[y])                                      //wenn element von parent B an der leeren Stelle schon in child ist
                    {
                        alreadyInTheChild=true;                                             //dann kann man zum nächsten element in parent B gehen
                        y=c;
                    }
                }
                
                if(alreadyInTheChild==false)                                            //if the element is not in the child 
                {
                    child.Tour.Insert(c+counter,parentB.Tour[p]);                                       //then put the element into the child
                    counter+=1;
                }
            }
            if(counter<counterMax)                                                      //wenn noch nicht alle leeren indizes im child voll sind dann muss man am anfang von parent B weitermachen
            {
                for(int p=1; p<c; p++)                                      //in parent B alle ab cutting point durchgehen
                {                                                                                   
                    bool alreadyInTheChild=false;
                    for(int y=0; y<c; y++)                                                      //in child alle die schon drinnen sind durchgehen
                    {
                        if(parentB.Tour[p]==child.Tour[y])                                      //wenn element von parent B an der leeren Stelle schon in child ist
                        {
                            alreadyInTheChild=true;                                             //dann kann man zum nächsten element in parent B gehen
                            y=c;
                        }
                    }
                    
                    if(alreadyInTheChild==false)                                            //wenn element noch nicht in child ist
                    {
                        child.Tour.Insert(c+counter,parentB.Tour[p]);                                       //dann einfügen
                        counter+=1;
                    }
                }   
            }
            child.Tour.Add(child.Tour[0]);                                              //das letzte element in child muss gleich dem ersten sein(--> tour schließen)
            child.CalculateCosts();
            return child;
    
    }
    
        
    //mutation
    
    public ResultingTour Mutation (ResultingTour tour)
    {
        bool alreadyMutated=false;
        //Console.WriteLine(tour.DistanceOfTheTour);
        /*Console.WriteLine("tour before mutation: ");
        for(int y=0; y<tour.Tour.Count; y++)                    //testing (printing tour before mutation)
            {
                Console.WriteLine(tour.Tour[y]);
            }
        Console.WriteLine();*/
        
        while(alreadyMutated==false)
        {
            //Console.WriteLine(tour.Tour.Count);
            int a = rand.Next(1,tour.Tour.Count-1);             //startnode/endnode must not be selected for swaping, because the startnode/endnode would maybe not be the same anymore
            int b = rand.Next(a+1,tour.Tour.Count-1);           //determine random indices of points which will be swapped
            //Console.WriteLine("a: " + a);
            //Console.WriteLine("b: " + b);
            
            if(a!=b)                                            //if a and b are different then swap (if a would be equal to b a swap wouldn't make any sense)
            {
                int temp = tour.Tour[a];
                //Console.WriteLine(tour.Tour[a]);              //testing
                tour.Tour[a] = tour.Tour[b];
                //Console.WriteLine(tour.Tour[a]);              //testing
                tour.Tour[b] = temp;
                alreadyMutated=true;                             
            }
        }
        
        /*Console.WriteLine("tour after mutation: ");
        for(int y=0; y<tour.Tour.Count; y++)                    //testing (printing tour after mutation)
            {
                Console.WriteLine(tour.Tour[y]);
                
            }*/
        
        tour.CalculateCosts();
        //Console.WriteLine(tour.DistanceOfTheTour);
        return tour;
    }
    
    //alternative mutation operator
    
    public ResultingTour MutationAlternative (ResultingTour tour)
    {
        /*for(int y=0; y<tour.Tour.Count; y++)                                                      //testing (printing tour before mutation)
            {
                Console.WriteLine("index: " + y + " - " + tour.Tour[y]);
            }*/
        bool alreadyMutated=false;
        
        while(alreadyMutated==false)
        {
            int a = rand.Next(1,tour.Tour.Count-1);             //startnode und endnode dürfen nicht zu tauschen ausgewählt werden, weil sonst ist der startnode nicht mehr gleich dem endnode
            int b = rand.Next(1,tour.Tour.Count-1);             //determine random indices of points in between which we will change the sequence of the points
            /*Console.WriteLine("index a: " + a);
            Console.WriteLine("index b: " + b);
            Console.WriteLine("a: " + tour.Tour[a]);
            Console.WriteLine("b: " + tour.Tour[b]);*/
        
            if(a!=b)                                            //if a and b are different then swap (if a would be equal to b a swap wouldn't make any sense)
            {
                if(a>b)
                {
                    tour.Tour.Reverse(b,a-b+1); 
                }
                if(a<b)
                {
                    tour.Tour.Reverse(a,b-a+1);
                }
                alreadyMutated=true;
            }
        
            /*for(int y=0; y<tour.Tour.Count; y++)                                                      //testing (printing tour after mutation)
                {
                    Console.WriteLine("index: " + y + " - " + tour.Tour[y]);
                }*/
        }   
        tour.CalculateCosts();
        return tour;
    }
        
    //method genetic algorithm
    
    public List <ResultingTour> GeneticAlgorithm (List <Point> pointlist, double mutationRate)
    {
        List <ResultingTour> population = new List <ResultingTour>();
        int populationSize=100;
        int numberOfGenerations=50;
            
        for(int d=0; d<populationSize; d++)                                                                     //create initial population
        {
            ResultingTour resultingTour=InitialTourGeneration(pointlist);
            population.Add(resultingTour);
            //Console.WriteLine("distance of tour " + d + " : " + population[d].DistanceOfTheTour);             //testing (printing the distances of all the 100 initial tours)
        }
        
​
        for(int g=0; g<numberOfGenerations; g++)                                                                //generate new generations
        {   
            List <ResultingTour> newPopulation = new List <ResultingTour>();
            //Console.WriteLine("population: " + population.Count + " , new population: " + newPopulation.Count);
            List<double> fitnessList=FitnessEvaluation(population);
            
            double maxFitnessValue=0;
            int indexOfMaxFitnessValue=-1;
            
            /*for(int i=0; i<fitnessList.Count; i++)
            {
                Console.WriteLine(fitnessList[i] + " \t" + population[i].DistanceOfTheTour);
            }*/
            
            for(int i=0; i<population.Count; i++)
            {
                if(fitnessList[i]>maxFitnessValue)
                {
                    maxFitnessValue=fitnessList[i];
                    indexOfMaxFitnessValue=i;
                }
            }
            
            //Console.WriteLine("tour: " + indexOfMaxFitnessValue + " distance: " + population[indexOfMaxFitnessValue].DistanceOfTheTour);          //testing (the best tour of the population gets saved in the next population)
            newPopulation.Add(new ResultingTour(population[indexOfMaxFitnessValue]));
            
            int maxMutations=(int)(populationSize*mutationRate);
            for(int i =0; i<maxMutations; i++)
            {
                //Console.WriteLine("i: " + i);
                ResultingTour newTour=Mutation(SelectParent(population,fitnessList));
                //Console.WriteLine(newTour.DistanceOfTheTour);
                newPopulation.Add(newTour);
            }
            
            for(int i=0; i<populationSize-maxMutations-1; i++)
            {
                ResultingTour newTour=Crossover(SelectParent(population,fitnessList),SelectParent(population,fitnessList), pointlist);
                newPopulation.Add(newTour);
            }
            population=newPopulation;
            //Console.WriteLine("best of the generation: " + population[indexOfMaxFitnessValue].DistanceOfTheTour);
            //Console.WriteLine("population: " + population.Count + " , new population: " + newPopulation.Count);
        }
        return population;
    }
        
​
    public static void Main()
    {
        Program p=new Program();
        FileHandler fl=new FileHandler();
        List <Point> pointlist = fl.ReadPoints();
        List <ResultingTour> population=p.GeneticAlgorithm(pointlist, 0.2);
        
        List<double> fitnessList= p.FitnessEvaluation(population);
        
        double maxFitnessValue=0;
        int indexOfMaxFitnessValue=-1;
            for(int i=0; i<population.Count; i++)
            {
                if(fitnessList[i]>maxFitnessValue)
                {
                    maxFitnessValue=fitnessList[i];
                    indexOfMaxFitnessValue=i;
                }
            }
        
        Console.WriteLine("The best tour after generating 50 generations is tour:" + indexOfMaxFitnessValue);
        for(int y=0; y<population[indexOfMaxFitnessValue].Tour.Count; y++)                                                      
            {
                Console.Write(population[indexOfMaxFitnessValue].Tour[y] + " ");
            }
        Console.WriteLine();
        Console.WriteLine("the corresponding distance is: " + population[indexOfMaxFitnessValue].DistanceOfTheTour);
        
        p.MutationAlternative (population[2]);
    }
}

input a number
nooooo

Last Run:	9:03:43 am
Compile:	0.198s
Execute:	0s
Memory:	32kb
CPU:	0s

View IL Code