C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.CodeDom;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

namespace JilFrühwirt 									
{		
			public class Point 								//1.) Define class Point & Resulting Tour 
			{												// member variables 
				public int ID { get; set; }					// property
				public int X { get; set; }					// property
				public int Y {get; set; }					// property
				public int Demand {get; set; }				// property
				public Point ( int id, int x, int y, int demand) // Constructor that sets the properties  
				{
					ID=id;									// watch upper and lower case
					X=x;									// watch upper and lower case
					Y=y;									// watch upper and lower case
					Demand = demand;						// watch upper and lower case
				}
				
				public double DistanceToPoint (Point p)		// Method to calculate the Distance between the point 
				{
				var temp1 = Math.Pow((this.X - p.X), 2);	// with .X and .Y we access the property of the class Point
				var temp2 = Math.Pow((this.Y - p.Y), 2);
				var result = Math.Sqrt(temp1+temp2);		
				return result;					
				} 
			}	
				public class ResultingTour 				
				{
				public List<int> Tour {get;set;}			// property	
				public int Capacity	{get;set;}				// property
				public ResultingTour (List <int> tour, int capa) // Constructor that sets the properties 
				{
					Tour = tour;
					Capacity = capa;
				}
			 }
	
			public class FilehandlingAndShapeReading 		//2.) Define class FilehandlingAndShapeReading 														
			{
				public List<Point> PointList; 				// declaration PointList 
				public Point Depot;  
				public int capa;
				
				public static void Main (string [] args)					
				{
					FilehandlingAndShapeReading fas = new FilehandlingAndShapeReading();	//Run functions/methods!
					fas.ReadInAll();

					fas.savingAlgorithm();
				}
				public void ReadInAll()			
				{			
					string [] GivendataNodes=  {"NAME : E-n51-k5","COMMENT : (Christophides and Eilon, Min no of trucks: 5, Optimal value: 521)","TYPE : CVRP",
											"DIMENSION : 51","EDGE_WEIGHT_TYPE : EUC_2D","CAPACITY : 160","NODE_COORD_SECTION","1 30 40","2 37 52","3 49 49",
											"4 52 64","5 20 26","6 40 30","7 21 47","8 17 63","9 31 62","10 52 33","11 51 21","12 42 41","13 31 32","14 5 25",
											"15 12 42","16 36 16","17 52 41","18 27 23","19 17 33","20 13 13","21 57 58","22 62 42","23 42 57","24 16 57",
											"25 8 52", "26 7 38", "27 27 68","28 30 48","29 43 67","30 58 48","31 58 27","32 37 69","33 38 46","34 46 10","35 61 33","36 62 63",
											"37 63 69","38 32 22","39 45 35","40 59 15","41 5 6","42 10 17","43 21 10","44 5 64","45 30 15","46 39 10",
											"47 32 39","48 25 32","49 25 55","50 48 28","51 56 37"};
					string [] GivendataDemand= {"DEMAND_SECTION","1 0","2 7","3 30","4 16","5 9","6 21","7 15","8 19","9 23","10 11","11 5","12 19","13 29",
												"14 23","15 21","16 10","17 15","18 3","19 41","20 9","21 28","22 8","23 8","24 16","25 10","26 28","27 7",
												"28 15","29 14","30 6","31 19","32 11","33 12","34 23","35 26","36 17","37 6","38 9","39 15","40 14","41 7",
												"42 27","43 13","44 11","45 16","46 10","47 5","48 25","49 17","50 18","51 10"};
					string [] GivendataDepot= {"DEPOT_SECTION"," 1","-1","EOF"};
				
							PointList = new List<Point>();			
					
							Depot = new Point(0,1,-1,0);					
							
							for(int i=0; i< GivendataNodes.Length; i++)																		// for loop: you go through each position in the string 
							{
								string firstPosition = GivendataNodes[i].Split(new char[0],StringSplitOptions.RemoveEmptyEntries)[0]; 		// you filter for the first position in the position 
								
								int j = 0;
								if (int.TryParse(firstPosition, out j) == true)															// if you can convert the first position in the position into a number (int) you continue 
								{																										//...with the if function and add the number to points. If you cannot convert it into int, the system skipps that position s
									int id = Int32.Parse(GivendataNodes[i].Split(new char[0],StringSplitOptions.RemoveEmptyEntries)[0]);	// ID = first Position 
									int X = Int32.Parse(GivendataNodes[i].Split(new char[0],StringSplitOptions.RemoveEmptyEntries)[1]);		// x-coordinate = second position 
									int Y = Int32.Parse(GivendataNodes[i].Split(new char[0],StringSplitOptions.RemoveEmptyEntries)[2]);		// y-coordinate = third position 	
									int Demand = 0;
																		
									if(id == 1)																								// Because node 1 corresponds to the depot, if ID of the point is one
									{
										Depot = new Point(id,X,Y,Demand);																	//...node is the depot!
									}
									else																									// If ID not equal to one add point to PointList!
									{		
										PointList.Add(new Point(id,X,Y,Demand));																
									}
								}
								else if (firstPosition.Equals("CAPACITY"))																	// Here we filter the string for the capacity...
								{
									capa = Int32.Parse(GivendataNodes[i].Split(new char[0],StringSplitOptions.RemoveEmptyEntries)[2]);		//...[2] because 160 is on the third position of the string!
								}
							}	
											
							for(int i=1; i < GivendataDemand.Length; i++)																	// filter demand from the string and add it to the point
							{
								if(i == 1)																									// for the first node which is the depot the demand is zero!
								{															
									Depot.Demand = 0;
								}
								else
								{
									int demand = Int32.Parse(GivendataDemand[i].Split(new char[0],StringSplitOptions.RemoveEmptyEntries)[1]);// for the remaining points we split the numbers on the second position [1]...
									PointList[i-2].Demand = demand;																			// ...and add it to the points in PointList!
								}								
							}		
				}	
				
				public double CalculateSavingsValue(Point p1, Point p2){												//SavingsAlgorithm 
					
					double savings = p1.DistanceToPoint(Depot) + p2.DistanceToPoint(Depot) - p1.DistanceToPoint(p2);	// Calculation of Savings
					
					return savings;
				}
				
				public Dictionary<string, double> sortedSavingMap(){						//		Key = string, value = double, return dictionary 								
					
					Dictionary<string, double> dict = new Dictionary<string, double>();		// 		Declaration & initialization 
					
					for(int i = 0; i < PointList.Count; i++){								
						for(int j = 0; j < PointList.Count; j++){
							if(i != j && j > i){														// do not compare point with itself and only compare once!
								double savings = this.CalculateSavingsValue(PointList[i],PointList[j]);	// calculate savings from point i to j 
								string key = (i+2).ToString() + "," + (j+2).ToString();					// generate key 
								dict.Add(key,savings);													// add to dictonary 
							}							
						}
					}
					dict = dict.OrderByDescending(x => x.Value).ToDictionary(x => x.Key, x => x.Value);	// Sort in descending order!
					return dict;
				}
				
				public void savingAlgorithm(){
					
					// Tour: Depot - single Node - depot
					List<ResultingTour> allTours = new List<ResultingTour>();
					foreach(var i in PointList){		
						List<int> singleTour = new List<int>();
						singleTour.Add(Depot.ID);
						singleTour.Add(i.ID);
						singleTour.Add(Depot.ID);
											
						allTours.Add(new ResultingTour(singleTour, capa - i.Demand));					// Fill all tours with single tours and the remaining capacity!
					}	
					
					
					//Calculate Savings
					Dictionary<string, double> dict = sortedSavingMap();						
					foreach(var i in dict){
						string[] key = i.Key.Split(',');												// Split key into integers
						int firstNode = Int32.Parse(key[0]);	
						int secondNode = Int32.Parse(key[1]);
												
						int firstTourPosition = -1;														// Declaration & initialization with invalid value for control!
						int secondTourPosition = -1;
						bool firstStart = false;														// first node of key at start or end in tour
						bool firstEnd = false;
						bool secondStart = false;														// second node of key at start or end in tour 
						bool secondEnd = false;
						
						// Calculate position
						for(int j = 0; j < allTours.Count; j++){										// If current tour includes the node, return Nodeindex within the tour... 
								if(allTours[j].Tour.Contains(firstNode)){								
									int firstListIndex = allTours[j].Tour.IndexOf(firstNode);			// wo in single tour er sich befindet der erste Key node
									
									if(allTours[j].Tour[firstListIndex-1] == 1){						//...if index before the node is zero change the regarding boolean variable and  
										firstStart = true;												//... note position of the node.
										firstTourPosition = j;
									}else if(allTours[j].Tour[firstListIndex+1] == 1){					// analog to if step
										firstEnd = true;
										firstTourPosition = j;
									}
								}				
								if(allTours[j].Tour.Contains(secondNode)){								// analog to first node. 
									int secondListIndex = allTours[j].Tour.IndexOf(secondNode);
									if(allTours[j].Tour[secondListIndex-1] == 1){
										secondStart = true;
										secondTourPosition = j;
									}else if(allTours[j].Tour[secondListIndex+1] == 1){
										secondEnd = true;
										secondTourPosition = j;
									}
								}
								if(secondTourPosition == firstTourPosition){							// if both keys in same tour set all to false!!!
									firstStart = false;
									firstEnd = false;
									secondStart = false;
									secondEnd = false;
								}
						}
							if(secondEnd && firstStart){																		// first key at start, scond key at end
								if(allTours[secondTourPosition].Capacity - (160 - allTours[firstTourPosition].Capacity) > 0){ 	//If you combine both tours is there still enough capacity left?
									allTours[firstTourPosition].Tour.RemoveAt(0);												// Delete starting depot of first tour
									allTours[secondTourPosition].Tour.RemoveAt(allTours[secondTourPosition].Tour.Count - 1);	// Delete ending depot of second tour

									allTours[secondTourPosition].Tour.AddRange(allTours[firstTourPosition].Tour);				// Merge tours!
									allTours[secondTourPosition].Capacity -= (160 - allTours[firstTourPosition].Capacity);		// Calculate remaining capacity!

									allTours.RemoveAt(firstTourPosition);														// Remove appended tour!
								}
							}
							else if(secondStart && firstEnd){
								if(allTours[firstTourPosition].Capacity -  (160 - allTours[secondTourPosition].Capacity) > 0){	// analog to secondEnd && firstStart just the other way around
									allTours[firstTourPosition].Tour.RemoveAt(allTours[firstTourPosition].Tour.Count - 1);
									allTours[secondTourPosition].Tour.RemoveAt(0);

									allTours[firstTourPosition].Tour.AddRange(allTours[secondTourPosition].Tour);
									allTours[firstTourPosition].Capacity -= (160 - allTours[secondTourPosition].Capacity);
									
									allTours.RemoveAt(secondTourPosition);
								}	
							}
							else if(secondStart && firstStart){
								if(allTours[firstTourPosition].Capacity -  (160 - allTours[secondTourPosition].Capacity) > 0){	// Capacity left?
									allTours[firstTourPosition].Tour.RemoveAt(0);												// Remove starting depots of tours
									allTours[secondTourPosition].Tour.RemoveAt(0);												// Remove starting depots of tours

									allTours[firstTourPosition].Tour.Reverse();													// Invert one tour to combine them!
									allTours[firstTourPosition].Tour.AddRange(allTours[secondTourPosition].Tour);				// Append the other tour.
									allTours[firstTourPosition].Capacity -= (160 - allTours[secondTourPosition].Capacity);		// Calculate remaining capacity

									allTours.RemoveAt(secondTourPosition);														// Remove appended tour!
								}
							}
							else if((secondEnd && firstEnd)){	
								if(allTours[firstTourPosition].Capacity -  (160 - allTours[secondTourPosition].Capacity) > 0){	// analog just with ending depots of tour!
									allTours[firstTourPosition].Tour.RemoveAt(allTours[firstTourPosition].Tour.Count - 1);
									allTours[secondTourPosition].Tour.RemoveAt(allTours[secondTourPosition].Tour.Count - 1);

									allTours[secondTourPosition].Tour.Reverse();
									allTours[firstTourPosition].Tour.AddRange(allTours[secondTourPosition].Tour);
									allTours[firstTourPosition].Capacity -= (160 - allTours[secondTourPosition].Capacity);									
									
									allTours.RemoveAt(secondTourPosition);

								}
							}
					}

					
					for(int i = 0; i < allTours.Count; i++){																		//Built string!
						String output = "Tour "+ (i+1) +": 1, ";
						double distance = 0;
						distance += Depot.DistanceToPoint(PointList[allTours[i].Tour[1]-2]);										// Distance from depot to first node
						for(int j = 1; j < allTours[i].Tour.Count-2; j++){														
								output += allTours[i].Tour[j].ToString() + ", ";													// Append ID to tour-output 
								distance += PointList[allTours[i].Tour[j]-2].DistanceToPoint(PointList[allTours[i].Tour[j+1]-2]);	// Add distance to total distance 
						}
						output += (allTours[i].Tour[(allTours[i].Tour.Count - 2)]) + ", " + (1).ToString();							// Add last node and end depot (0)
						distance += PointList[allTours[i].Tour[(allTours[i].Tour.Count - 2)]-2].DistanceToPoint(Depot);				// Add distance from last node to end depot
						
						output += " | Load: "+ (160 - allTours[i].Capacity).ToString() + " | Length: " + distance;					//Finish output!
						Console.WriteLine(output);
					}
				}

			}

}

​x
 
using System;
using System.CodeDom;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
​
namespace JilFrühwirt                                   
{       
            public class Point                              //1.) Define class Point & Resulting Tour 
            {                                               // member variables 
                public int ID { get; set; }                 // property
                public int X { get; set; }                  // property
                public int Y {get; set; }                   // property
                public int Demand {get; set; }              // property
                public Point ( int id, int x, int y, int demand) // Constructor that sets the properties  
                {
                    ID=id;                                  // watch upper and lower case
                    X=x;                                    // watch upper and lower case
                    Y=y;                                    // watch upper and lower case
                    Demand = demand;                        // watch upper and lower case
                }
                
                public double DistanceToPoint (Point p)     // Method to calculate the Distance between the point 
                {
                var temp1 = Math.Pow((this.X - p.X), 2);    // with .X and .Y we access the property of the class Point
                var temp2 = Math.Pow((this.Y - p.Y), 2);
                var result = Math.Sqrt(temp1+temp2);        
                return result;                  
                } 
            }   
                public class ResultingTour              
                {
                public List<int> Tour {get;set;}            // property 
                public int Capacity {get;set;}              // property
                public ResultingTour (List <int> tour, int capa) // Constructor that sets the properties 
                {
                    Tour = tour;
                    Capacity = capa;
                }
             }
    
            public class FilehandlingAndShapeReading        //2.) Define class FilehandlingAndShapeReading                                                      
            {
                public List<Point> PointList;               // declaration PointList 
                public Point Depot;  
                public int capa;
                
                public static void Main (string [] args)                    
                {
                    FilehandlingAndShapeReading fas = new FilehandlingAndShapeReading();    //Run functions/methods!
                    fas.ReadInAll();
​
                    fas.savingAlgorithm();
                }
                public void ReadInAll()         
                {           
                    string [] GivendataNodes=  {"NAME : E-n51-k5","COMMENT : (Christophides and Eilon, Min no of trucks: 5, Optimal value: 521)","TYPE : CVRP",
                                            "DIMENSION : 51","EDGE_WEIGHT_TYPE : EUC_2D","CAPACITY : 160","NODE_COORD_SECTION","1 30 40","2 37 52","3 49 49",
                                            "4 52 64","5 20 26","6 40 30","7 21 47","8 17 63","9 31 62","10 52 33","11 51 21","12 42 41","13 31 32","14 5 25",
                                            "15 12 42","16 36 16","17 52 41","18 27 23","19 17 33","20 13 13","21 57 58","22 62 42","23 42 57","24 16 57",
                                            "25 8 52", "26 7 38", "27 27 68","28 30 48","29 43 67","30 58 48","31 58 27","32 37 69","33 38 46","34 46 10","35 61 33","36 62 63",
                                            "37 63 69","38 32 22","39 45 35","40 59 15","41 5 6","42 10 17","43 21 10","44 5 64","45 30 15","46 39 10",
                                            "47 32 39","48 25 32","49 25 55","50 48 28","51 56 37"};
                    string [] GivendataDemand= {"DEMAND_SECTION","1 0","2 7","3 30","4 16","5 9","6 21","7 15","8 19","9 23","10 11","11 5","12 19","13 29",
                                                "14 23","15 21","16 10","17 15","18 3","19 41","20 9","21 28","22 8","23 8","24 16","25 10","26 28","27 7",
                                                "28 15","29 14","30 6","31 19","32 11","33 12","34 23","35 26","36 17","37 6","38 9","39 15","40 14","41 7",
                                                "42 27","43 13","44 11","45 16","46 10","47 5","48 25","49 17","50 18","51 10"};
                    string [] GivendataDepot= {"DEPOT_SECTION"," 1","-1","EOF"};
                
                            PointList = new List<Point>();          
                    
                            Depot = new Point(0,1,-1,0);                    
                            
                            for(int i=0; i< GivendataNodes.Length; i++)                                                                     // for loop: you go through each position in the string 
                            {
                                string firstPosition = GivendataNodes[i].Split(new char[0],StringSplitOptions.RemoveEmptyEntries)[0];       // you filter for the first position in the position 
                                
                                int j = 0;
                                if (int.TryParse(firstPosition, out j) == true)                                                         // if you can convert the first position in the position into a number (int) you continue 
                                {                                                                                                       //...with the if function and add the number to points. If you cannot convert it into int, the system skipps that position s
                                    int id = Int32.Parse(GivendataNodes[i].Split(new char[0],StringSplitOptions.RemoveEmptyEntries)[0]);    // ID = first Position 
                                    int X = Int32.Parse(GivendataNodes[i].Split(new char[0],StringSplitOptions.RemoveEmptyEntries)[1]);     // x-coordinate = second position 
                                    int Y = Int32.Parse(GivendataNodes[i].Split(new char[0],StringSplitOptions.RemoveEmptyEntries)[2]);     // y-coordinate = third position    
                                    int Demand = 0;
                                                                        
                                    if(id == 1)                                                                                             // Because node 1 corresponds to the depot, if ID of the point is one
                                    {
                                        Depot = new Point(id,X,Y,Demand);                                                                   //...node is the depot!
                                    }
                                    else                                                                                                    // If ID not equal to one add point to PointList!
                                    {       
                                        PointList.Add(new Point(id,X,Y,Demand));                                                                
                                    }
                                }
                                else if (firstPosition.Equals("CAPACITY"))                                                                  // Here we filter the string for the capacity...
                                {
                                    capa = Int32.Parse(GivendataNodes[i].Split(new char[0],StringSplitOptions.RemoveEmptyEntries)[2]);      //...[2] because 160 is on the third position of the string!
                                }
                            }   
                                            
                            for(int i=1; i < GivendataDemand.Length; i++)                                                                   // filter demand from the string and add it to the point
                            {
                                if(i == 1)                                                                                                  // for the first node which is the depot the demand is zero!
                                {                                                           
                                    Depot.Demand = 0;
                                }
                                else
                                {
                                    int demand = Int32.Parse(GivendataDemand[i].Split(new char[0],StringSplitOptions.RemoveEmptyEntries)[1]);// for the remaining points we split the numbers on the second position [1]...
                                    PointList[i-2].Demand = demand;                                                                         // ...and add it to the points in PointList!
                                }                               
                            }       
                }   
                
                public double CalculateSavingsValue(Point p1, Point p2){                                                //SavingsAlgorithm 
                    
                    double savings = p1.DistanceToPoint(Depot) + p2.DistanceToPoint(Depot) - p1.DistanceToPoint(p2);    // Calculation of Savings
                    
                    return savings;
                }
                
                public Dictionary<string, double> sortedSavingMap(){                        //      Key = string, value = double, return dictionary                                 
                    
                    Dictionary<string, double> dict = new Dictionary<string, double>();     //      Declaration & initialization 
                    
                    for(int i = 0; i < PointList.Count; i++){                               
                        for(int j = 0; j < PointList.Count; j++){
                            if(i != j && j > i){                                                        // do not compare point with itself and only compare once!
                                double savings = this.CalculateSavingsValue(PointList[i],PointList[j]); // calculate savings from point i to j 
                                string key = (i+2).ToString() + "," + (j+2).ToString();                 // generate key 
                                dict.Add(key,savings);                                                  // add to dictonary 
                            }                           
                        }
                    }
                    dict = dict.OrderByDescending(x => x.Value).ToDictionary(x => x.Key, x => x.Value); // Sort in descending order!
                    return dict;
                }
                
                public void savingAlgorithm(){
                    
                    // Tour: Depot - single Node - depot
                    List<ResultingTour> allTours = new List<ResultingTour>();
                    foreach(var i in PointList){        
                        List<int> singleTour = new List<int>();
                        singleTour.Add(Depot.ID);
                        singleTour.Add(i.ID);
                        singleTour.Add(Depot.ID);
                                            
                        allTours.Add(new ResultingTour(singleTour, capa - i.Demand));                   // Fill all tours with single tours and the remaining capacity!
                    }   
                    
                    
                    //Calculate Savings
                    Dictionary<string, double> dict = sortedSavingMap();                        
                    foreach(var i in dict){
                        string[] key = i.Key.Split(',');                                                // Split key into integers
                        int firstNode = Int32.Parse(key[0]);    
                        int secondNode = Int32.Parse(key[1]);
                                                
                        int firstTourPosition = -1;                                                     // Declaration & initialization with invalid value for control!
                        int secondTourPosition = -1;
                        bool firstStart = false;                                                        // first node of key at start or end in tour
                        bool firstEnd = false;
                        bool secondStart = false;                                                       // second node of key at start or end in tour 
                        bool secondEnd = false;
                        
                        // Calculate position
                        for(int j = 0; j < allTours.Count; j++){                                        // If current tour includes the node, return Nodeindex within the tour... 
                                if(allTours[j].Tour.Contains(firstNode)){                               
                                    int firstListIndex = allTours[j].Tour.IndexOf(firstNode);           // wo in single tour er sich befindet der erste Key node
                                    
                                    if(allTours[j].Tour[firstListIndex-1] == 1){                        //...if index before the node is zero change the regarding boolean variable and  
                                        firstStart = true;                                              //... note position of the node.
                                        firstTourPosition = j;
                                    }else if(allTours[j].Tour[firstListIndex+1] == 1){                  // analog to if step
                                        firstEnd = true;
                                        firstTourPosition = j;
                                    }
                                }               
                                if(allTours[j].Tour.Contains(secondNode)){                              // analog to first node. 
                                    int secondListIndex = allTours[j].Tour.IndexOf(secondNode);
                                    if(allTours[j].Tour[secondListIndex-1] == 1){
                                        secondStart = true;
                                        secondTourPosition = j;
                                    }else if(allTours[j].Tour[secondListIndex+1] == 1){
                                        secondEnd = true;
                                        secondTourPosition = j;
                                    }
                                }
                                if(secondTourPosition == firstTourPosition){                            // if both keys in same tour set all to false!!!
                                    firstStart = false;
                                    firstEnd = false;
                                    secondStart = false;
                                    secondEnd = false;
                                }
                        }
                            if(secondEnd && firstStart){                                                                        // first key at start, scond key at end
                                if(allTours[secondTourPosition].Capacity - (160 - allTours[firstTourPosition].Capacity) > 0){   //If you combine both tours is there still enough capacity left?
                                    allTours[firstTourPosition].Tour.RemoveAt(0);                                               // Delete starting depot of first tour
                                    allTours[secondTourPosition].Tour.RemoveAt(allTours[secondTourPosition].Tour.Count - 1);    // Delete ending depot of second tour
​
                                    allTours[secondTourPosition].Tour.AddRange(allTours[firstTourPosition].Tour);               // Merge tours!
                                    allTours[secondTourPosition].Capacity -= (160 - allTours[firstTourPosition].Capacity);      // Calculate remaining capacity!
​
                                    allTours.RemoveAt(firstTourPosition);                                                       // Remove appended tour!
                                }
                            }
                            else if(secondStart && firstEnd){
                                if(allTours[firstTourPosition].Capacity -  (160 - allTours[secondTourPosition].Capacity) > 0){  // analog to secondEnd && firstStart just the other way around
                                    allTours[firstTourPosition].Tour.RemoveAt(allTours[firstTourPosition].Tour.Count - 1);
                                    allTours[secondTourPosition].Tour.RemoveAt(0);
​
                                    allTours[firstTourPosition].Tour.AddRange(allTours[secondTourPosition].Tour);
                                    allTours[firstTourPosition].Capacity -= (160 - allTours[secondTourPosition].Capacity);
                                    
                                    allTours.RemoveAt(secondTourPosition);
                                }   
                            }
                            else if(secondStart && firstStart){
                                if(allTours[firstTourPosition].Capacity -  (160 - allTours[secondTourPosition].Capacity) > 0){  // Capacity left?
                                    allTours[firstTourPosition].Tour.RemoveAt(0);                                               // Remove starting depots of tours
                                    allTours[secondTourPosition].Tour.RemoveAt(0);                                              // Remove starting depots of tours
​
                                    allTours[firstTourPosition].Tour.Reverse();                                                 // Invert one tour to combine them!
                                    allTours[firstTourPosition].Tour.AddRange(allTours[secondTourPosition].Tour);               // Append the other tour.
                                    allTours[firstTourPosition].Capacity -= (160 - allTours[secondTourPosition].Capacity);      // Calculate remaining capacity
​
                                    allTours.RemoveAt(secondTourPosition);                                                      // Remove appended tour!
                                }
                            }
                            else if((secondEnd && firstEnd)){   
                                if(allTours[firstTourPosition].Capacity -  (160 - allTours[secondTourPosition].Capacity) > 0){  // analog just with ending depots of tour!
                                    allTours[firstTourPosition].Tour.RemoveAt(allTours[firstTourPosition].Tour.Count - 1);
                                    allTours[secondTourPosition].Tour.RemoveAt(allTours[secondTourPosition].Tour.Count - 1);
​
                                    allTours[secondTourPosition].Tour.Reverse();
                                    allTours[firstTourPosition].Tour.AddRange(allTours[secondTourPosition].Tour);
                                    allTours[firstTourPosition].Capacity -= (160 - allTours[secondTourPosition].Capacity);                                  
                                    
                                    allTours.RemoveAt(secondTourPosition);
​
                                }
                            }
                    }
​
                    
                    for(int i = 0; i < allTours.Count; i++){                                                                        //Built string!
                        String output = "Tour "+ (i+1) +": 1, ";
                        double distance = 0;
                        distance += Depot.DistanceToPoint(PointList[allTours[i].Tour[1]-2]);                                        // Distance from depot to first node
                        for(int j = 1; j < allTours[i].Tour.Count-2; j++){                                                      
                                output += allTours[i].Tour[j].ToString() + ", ";                                                    // Append ID to tour-output 
                                distance += PointList[allTours[i].Tour[j]-2].DistanceToPoint(PointList[allTours[i].Tour[j+1]-2]);   // Add distance to total distance 
                        }
                        output += (allTours[i].Tour[(allTours[i].Tour.Count - 2)]) + ", " + (1).ToString();                         // Add last node and end depot (0)
                        distance += PointList[allTours[i].Tour[(allTours[i].Tour.Count - 2)]-2].DistanceToPoint(Depot);             // Add distance from last node to end depot
                        
                        output += " | Load: "+ (160 - allTours[i].Capacity).ToString() + " | Length: " + distance;                  //Finish output!
                        Console.WriteLine(output);
                    }
                }
​
            }
​
}
            
                        
​
                

Input 1, 2 returns 0
Input 3, 2 returns 0
Input 2, 2 returns 0

Last Run:	5:08:37 pm
Compile:	0.126s
Execute:	0.016s
Memory:	0b
CPU:	0.031s

View IL Code