private void RemoveRedundantSet()
{
SCPSolution improved = _currSolution.Clone();
List <int> blacklist = new List <int>();
_currSolution.ComputeAttributeRedundancies();
foreach (var set in _currSolution.Sets)
{
bool useless = true;
foreach (var a in set.Attributes)
{
if (a.Redundancy <= 1)
{
useless = false;
break;
}
}
if (useless)
{
set.Attributes.ForEach(a => a.Redundancy--);
blacklist.Add(set.Tag);
}
}
blacklist.ForEach(b => improved.Sets.Remove(improved.Sets.Find(s => s.Tag.ToString() == b.ToString())));
if (improved.Cost < _currSolution.Cost)
{
_currSolution = improved;
}
}
public void MarkPrimeSets(SCPSolution solution)
{
solution.Sets.ForEach(set =>
{
set.Prime = IsPrimeSet(set);
});
}
private void HorizantalSelection()
{
sp.Restart();
SCPDataSet source = (SCPDataSet)_problem.Source.Clone();
// source.Attributes = AttributeProbability(source.Attributes,source.Sets.Count);
//source.Sets = Weighting(source.Sets);
//List<SCPSet> candidates = GetCandidates(source.Sets);
Stack <SCPSet> starts = new Stack <SCPSet>(source.Sets);
List <SCPSolution> solutions = new List <SCPSolution>();
while (starts.Count > 0)
{
starts.Peek().Visit = true;
List <SCPSet> best = Fitness(new List <SCPSet>()
{
starts.Pop()
}, ((SCPDataSet)source.Clone()).Sets);
SCPSolution solution = new SCPSolution();
solution.Sets = best;
solutions.Add(RemoveRedundantSet(solution));
}
FSolution = solutions.OrderBy(s => s.Cost).First();
sp.Stop();
}
public double Execute(IProblem problem)
{
_sp.Restart();
Initializer(problem);
_currSolution.ComputeAttributeRedundancies();
List <double> cost_history = new List <double>();
while (true)
{
if (cost_history.Count > 2)
{
if (cost_history[cost_history.Count - 1] == cost_history[cost_history.Count - 2])
{
break;
}
}
//STEP#1
ImproveByOneNeighborhood();
if (_currSolution.Cost < _opSolution.Cost)
{
_opSolution = _currSolution.Clone();
}
//STEP#2
ImproveByTwoNeighborhoods();
if (_currSolution.Cost < _opSolution.Cost)
{
_opSolution = _currSolution.Clone();
}
//STEP#3
ImproveByThreeNeighborhoods();
if (_currSolution.Cost < _opSolution.Cost)
{
_opSolution = _currSolution.Clone();
}
//STEP#4
RemoveRedundantSet();
if (_currSolution.Cost < _opSolution.Cost)
{
_opSolution = _currSolution.Clone();
}
cost_history.Add(_opSolution.Cost);
}
_sp.Stop();
return(OptimumSultion.Cost);
}
private bool IsFeasible(SCPSolution solution)
{
HashSet <int> problem_att = new HashSet <int>();
_problem.Source.Attributes.ForEach(a => problem_att.Add(a.Tag));
HashSet <int> solution_att = new HashSet <int>();
solution.USet.ForEach(a => solution_att.Add(a));
return(problem_att.IsSubsetOf(solution_att));
}
public void Test()
{
SCP problem = (SCP)scpParser.Problem;
SCPDataSet source = (SCPDataSet)problem.Source.Clone();
List <Tuple <SCPAttribute, SCPSet> > panel = new List <Tuple <SCPAttribute, SCPSet> >();
source.Attributes.ForEach(a =>
{
a.Cost = a.GetCheapestCost();
panel.Add(new Tuple <SCPAttribute, SCPSet>(a, a.GetCheapestSet()));
});
int covered = 0;
SCPSolution solution2 = new SCPSolution();
while (covered < source.Attributes.Count)
{
source.Attributes = source.Attributes.OrderByDescending(a => a.Cost).ToList();
source.Attributes.ForEach(a1 =>
{
a1.Visit = false;
a1.UsedIn.ForEach(s =>
{
s.Weight = s.Cost / s.Frequency;
});
a1.UsedIn = a1.UsedIn.OrderBy(ui => ui.Weight).ToList();
});
SCPSet set = source.Attributes.Where(at => at.Visit == false).First().UsedIn.First();
set.Attributes.ForEach(a =>
{
if (a.Visit == false)
{
a.Visit = true;
covered++;
a.UsedIn.ForEach(s => s.Frequency--);
}
});
if (set.Visit == false)
{
solution2.Sets.Add(set);
}
set.Visit = true;
}
RemoveRedundantSet(solution2);
bool result = IsFeasible(solution2, problem);
}
private bool IsFeasible(SCPSolution solution)
{
if (solution.Sets.Count <= 0)
{
return(false);
}
#region Step#1 Exhustive test
List <int> attributes = new List <int>();
solution.Sets.ForEach(s => s.Attributes.ForEach(a => attributes.Add(a.Tag)));
attributes = attributes.OrderBy(a => a).ToList();
for (int i = 1; i < attributes.Count; i++)
{
if (attributes[i] - attributes[i - 1] > 1)
{
return(false);
}
}
#endregion
#region Step#2 Formulation test nx(n-1)/2
int n = _problem.Matrix.Size.X;
int sum1 = n * (n + 1) / 2;
int seed = attributes[0];
int sum2 = seed;
for (int i = 1; i < attributes.Count; i++)
{
if (attributes[i] != seed)
{
seed = attributes[i];
sum2 += seed;
}
}
if (sum2 != sum1)
{
return(false);
}
#endregion
#region Step#3 Hashing test
int[] list = new int[n];
foreach (int item in attributes)
{
list[item - 1] = item;
}
#endregion
return(true);
}
private SCPSolution RemoveRedundantSet(SCPSolution solution)
{
if (solution.Sets.Count == 1)
{
return(solution);
}
SCPSolution improved = solution.Clone();
List <int> blacklist = new List <int>();
solution.ComputeAttributeRedundancies();
solution.Sets = solution.Sets.OrderByDescending(s => s.Cost).ToList();
foreach (var set in solution.Sets)
{
bool useless = true;
foreach (var a in set.Attributes)
{
if (a.Redundancy <= 1)
{
useless = false;
break;
}
}
if (useless)
{
set.Attributes.ForEach(a =>
{
a.Redundancy--;
});
blacklist.Add(set.Tag);
}
}
blacklist.ForEach(b => improved.Sets.Remove(improved.Sets.Find(s => s.Tag.ToString() == b.ToString())));
if (improved.Cost < solution.Cost)
{
return(improved);
}
else
{
return(solution);
}
}
private void improve()
{
while (true)
{
_problem.Source.Sets.ForEach(set =>
{
if (_problem.Solution.Sets.Exists(s => s.Tag == set.Tag) == false)
{
_problem.Solution.Adapt(set);
}
});
SCPSolution solution = RemoveRedundantSet(_problem.Solution);
if (solution.Cost < OptimumSultion.Cost)
{
OptimumSultion = solution;
}
}
}
private void HorizantalSelection()
{
OptimumSultion = new SCPSolution();
sp.Restart();
int coveredatt = 0;
int att_count = _problem.Matrix.Size.X;
while (coveredatt < att_count)
{
SCPSet set = _problem.Source.GetLightestNotVisitedSet();
bool valuable = false;
set.Attributes.ForEach(a1 =>
{
if (a1.Visit == false)
{
if (_problem.Source.Attributes.Select(a => a.Tag).ToList().Exists(a => a == a1.Tag))
{
valuable = true;
a1.Visit = true;
coveredatt++;
a1.UsedIn.ForEach(s1 =>
{
s1.Frequency--;
});
}
}
});
if (set.Visit == false && valuable)
{
((SCPSolution)OptimumSultion).Sets.Add(set);
}
_problem.Source.Sets.Find(s => s.Tag == set.Tag).Visit = true;
_problem.Source.Weighting();
}
sp.Stop();
}
private void Initializer(IProblem problem)
{
_problem = (SCP)problem;
_currSolution = _problem.Solution.Clone();
_opSolution = _currSolution.Clone();
}
public SCPImprovementGreedy()
{
FSolution = new SCPSolution();
}
public SCP(MatrixSize size)
{
Matrix = new Matrix <int>(size);
Solution = new SCPSolution();
}
public SCPGreedyImprovement()
{
OptimumSultion = new SCPSolution();
}
public SCPFirstOrderGreedy()
{
FSolution = new SCPSolution();
}