public Solution Run(State s, int LSTrials)
{
this.LSTrials = LSTrials;
Solution best = null;
IList<Solution> solutions;
//IList<Difference> differences = new List<Difference>(populationSize);
solutions = Initialize(s);
for (int i = 0; i < s.Iterations; ++i)
{
Evaluate(solutions, s);
solutions = solutions.OrderByDescending(e => e.Evaluation).ToList();
best = solutions.Last();
LocalSearch(best, s);
//differences.Clear();
for (int j = 0; j < s.PopulationSize - 1; ++j)
solutions[j].MergeWithBest(best, randomizer);
}
return best;
}
public Solution GenerateGreedySolution(State s)
{
IList<City> sourceCities = new List<City>(s.Cities);
IList<City> destinationList = new List<City>(s.Cities.Count);
City previousCity = s.Warehouse;
int k = 0;
double minDistance;
double currentDistance;
int selectedCity;
while(sourceCities.Count > 0)
{
++k;
selectedCity = 0;
minDistance = sourceCities[0].Distance(previousCity);
for (int j = 1; j < sourceCities.Count; ++j)
{
currentDistance = sourceCities[j].Distance(previousCity);
if (currentDistance < minDistance)
{
minDistance = currentDistance;
selectedCity = j;
}
}
if (k == s.K)
{
previousCity = s.Warehouse;
k = 0;
}
else
previousCity = sourceCities[selectedCity];
destinationList.Add(sourceCities[selectedCity]);
sourceCities.RemoveAt(selectedCity);
}
return new Solution(destinationList);
}
static void Main(string[] args)
{
double gammaParam = 1.0;
double roParam = 0.0;
double betaParam = 1.0;
double sParam = 1.0;
int popParam = 100;
int iterParam = 300;
int lsParam = 5;
String fileName = null;
var p = new OptionSet() {
{ "g|gamma=",
"gamma parameter",
v => {gammaParam = Double.Parse(v,CultureInfo.InvariantCulture);} },
{ "r|ro=", "r parameter",
v => {roParam = Double.Parse(v,CultureInfo.InvariantCulture);} },
{ "s|sParam=", "s parameter",
v => {sParam = Double.Parse(v,CultureInfo.InvariantCulture);} },
{ "b|beta=", "beta parameter",
v => {betaParam = Double.Parse(v,CultureInfo.InvariantCulture);} },
{ "p|population=", "population size",
v => {popParam = int.Parse(v,CultureInfo.InvariantCulture);} },
{ "i|iterations=", "iterations number",
v => {iterParam = int.Parse(v,CultureInfo.InvariantCulture);} },
{ "ls|localsearch=", "number of trials in local search",
v => {lsParam = int.Parse(v,CultureInfo.InvariantCulture);} },
};
List<String> extra = new List<string>();
try
{
extra = p.Parse(new string[]{"basic\\100_k=3"});
if (extra.Count() == 0)
{
Console.WriteLine("File not given!");
return;
}
foreach (String str in extra)
{
List<City> readCities = new List<City>();
int k = int.Parse(str.Split('k')[1].Substring(1));
Console.WriteLine("Processing file: {0} with parameters k = {1}"
+ " gamma = {2} beta = {3} ro = {4} s = {5}",
str, k, gammaParam, betaParam, roParam, sParam);
int[] coords;
string[] fileLines;
fileLines = File.ReadAllLines(str);
for (int i = 1; i < fileLines.Length; ++i)
{
coords = fileLines[i].Split(' ').Select(s => int.Parse(s)).ToArray();
readCities.Add(new City(coords[0], coords[1]));
}
Console.WriteLine("Running file: {0} iterations on {1} population",
iterParam,popParam);
State state = new State(k, readCities);
state.Iterations = iterParam;
state.PopulationSize = popParam;
Optimalization o = new Optimalization();
Solution sol = o.Run(state,lsParam);
Console.WriteLine(sol.Evaluation);
/*List<City> l1 = new List<City>();
for (int i = 0; i < 11; ++i)
{
l1.Add(new City(10 * i, 10 * i));
}
Solution s1 = new Solution(new List<City>(l1));
l1.Reverse();
Solution s2 = new Solution(new List<City>(l1));
//
for (int i = 0; i < 10; ++i)
s1.MergeWithBest(s2);
Difference diff = new Difference(s1, s2);*/
/*Solution sol = new Solution(new List<City> { readCities[0], readCities[2], readCities[1], readCities[3] });
Solution best = new Solution(new List<City> { readCities[0], readCities[1], readCities[2], readCities[3] });
Console.WriteLine(sol);
Console.WriteLine(best);
sol.MergeWithBest(best);
Console.WriteLine(sol);*/
}
}
catch (OptionException e)
{
//don't give a f**k
}
Console.ReadLine();
}
private void Evaluate(IList<Solution> l, State state)
{
foreach(Solution s in l)
{
//s.Evaluate(state.Warehouse, state.K);
LocalSearch(s, state);
}
}
private void LocalSearch(Solution s, State state)
{
int m, n;
double baseEvaluation = s.Evaluate(state.Warehouse, state.K);
for (int i = 0; i < LSTrials; ++i)
{
m = randomizer.Next(s.Cities.Count);
do{
n = randomizer.Next(s.Cities.Count);
}while(m == n);
s.SwapCities(m, n);
if (s.Evaluate(state.Warehouse, state.K) < baseEvaluation)
{
//better permutation
baseEvaluation = s.Evaluation;
}
else
{
//worse permutation, we go back to previous one
s.SwapCities(m, n);
s.Evaluate(state.Warehouse, state.K);
}
}
}
private IList<Solution> Initialize(State s)
{
IList<Solution> solutions = new List<Solution>();
Solution solution;
solutions.Add(GenerateGreedySolution(s));
Console.WriteLine(solutions[0].Evaluate(s.Warehouse, s.K));
for (int i = 1; i < s.PopulationSize; ++i)
{
solution = new Solution(new List<City>(s.Cities));
Shuffle(solution);
solutions.Add(solution);
}
return solutions;
}
