///// <summary> ///// I think this method is initially where I intended to perform the cuts. ///// However, at this point, it is not really necessary. ///// </summary> ///// <param name="vertexToProcess"></param> ///// <param name="orphanedElements"></param> ///// <returns></returns> //[Obsolete("Warning: May not be necessary. Use the methods/properties on VertexNode instead.")] //private List<IAdjacencyDirectableVisitable> ProcessOrphanedElements(IAdjacencyDirectableVisitable vertexToProcess, // List<IAdjacencyDirectableVisitable> orphanedElements) //{ // if (orphanedElements.Any()) // i.e. if at least one vertex was orphaned, // { // if (orphanedElements.Count > 1) // { // throw new OrphanedVertexException("Too many orphaned vertices! (Not sure what to do.)"); // } // var firstOrphan = orphanedElements.FirstOrDefault(); // // If there was one orphan, then we need to take this vertex as the next step. // // We still need to check though if taking this vertex will orphan another. In that case, // // we have an impossible situation. // var doesFirstOrphanCutOrphanAnotherVertex = this.DoesCutOrphanVertex(vertex1: vertexToProcess, // vertex2: firstOrphan); // if (doesFirstOrphanCutOrphanAnotherVertex) // { // throw new OrphanedVertexException("Impossible situation. Too many orphans! "); // } // else // { // return orphanedElements; // //this.Visit(firstOrphan); // Otherwise, visit that orphan. // //DetermineWhichVertexToChoose(firstOrphan); // Then process it. // } // } // return orphanedElements; //} //public void AlternateProcessing(IAdjacencyDirectableVisitable firstVertex, // IAdjacencyDirectableVisitable secondVertex, // int counter) //{ //} ///// <summary> ///// This is for the first (external) call to this method. (It calls the other overload with default starting values.) ///// </summary> ///// <param name="firstVertex"></param> ///// <param name="secondVertex"></param> //public void AlternateProcessing(IAdjacencyDirectableVisitable firstVertex, // IAdjacencyDirectableVisitable secondVertex) //{ // AlternateProcessing(firstVertex, secondVertex, new Dictionary<int, IAdjacencyDirectableVisitable>(), 0 ); //} //public void AlternateProcessing(IAdjacencyDirectableVisitable firstVertex, // IAdjacencyDirectableVisitable secondVertex, // Dictionary<int, IAdjacencyDirectableVisitable> chosenVertices, // int counter) //{ // if (chosenVertices == null) // { // chosenVertices = new Dictionary<int, IAdjacencyDirectableVisitable>(); // } // if (firstVertex != null && secondVertex != null) // { // var pendingVerticesToProcess = new List<IAdjacencyDirectableVisitable>(); // counter++; // if (counter % 2 == 0) // { // //if (chosenVertices.Count >= 1) // //{ // // var mostRecentVertex = chosenVertices.Last(); // // if (chosenVertices.Count >= 2) // // { // // mostRecentVertex = chosenVertices.Reverse().Skip(1).Take(1).FirstOrDefault(); // // } // // if (chosenVertices.Count >= 3) // // { // // mostRecentVertex = chosenVertices.Reverse().Skip(1).Take(1).FirstOrDefault(); // // } // // // use this position AND the mostRecentVertexPosition to get the corresponding edge. IT SHOULD EXIST. // // // (But what if it was cut?) // // // We must get the edge and choose it. // // var visitedEdge = firstVertex.AdjacencyDirector.GetEdgeIncidentToBothVertices(firstVertex.Position, mostRecentVertex.Key); // // visitedEdge.Choose(); // //} // if (!chosenVertices.ContainsKey(firstVertex.Position)) // { // chosenVertices.Add(firstVertex.Position, firstVertex); // } // var oddChosenVertices = chosenVertices.ToList().Where((c, i) => i % 2 != 0).ToList(); // //var evenChosenVertices = chosenVertices.ToList().Where((c, i) => i % 2 == 0); // // firstVertex IS PART OF oddChosenVertices // if (oddChosenVertices.Count > 1) // { // var mostRecentVertex = oddChosenVertices[oddChosenVertices.Count - 2]; // // use this position AND the mostRecentVertexPosition to get the corresponding edge. IT SHOULD EXIST. // // (But what if it was cut?) // // We must get the edge and choose it. // if (mostRecentVertex.Key != firstVertex.Position) // { // var visitedEdge = firstVertex.AdjacencyDirector.GetEdgeIncidentToBothVertices(firstVertex.Position, mostRecentVertex.Key); // visitedEdge.Choose(); // } // } // this.Visit(firstVertex); // //nodes = this.DetermineWhichVertexToChoose(firstVertex, chosenVertices).Except(chosenVertices.Select(t => t.Value)).ToList(); // // The Except doesn't work yet. // var elementsToProcess = firstVertex.DecideNext.Values; // foreach (var adjacencyDirectableVisitable in elementsToProcess) // { // if (!chosenVertices.ContainsKey(adjacencyDirectableVisitable.Position)) // { // pendingVerticesToProcess.Add(adjacencyDirectableVisitable); // } // } // // How would I run this foreach node in nodes? I would need to snapshot the chosenVertices and pass // // them in a queue to this method. // foreach (var orphan in pendingVerticesToProcess) // { // AlternateProcessing(orphan, secondVertex, chosenVertices.DeepClone(), counter); // } // } // if (counter % 2 == 1) // { // if (!chosenVertices.ContainsKey(secondVertex.Position)) // Could be replaced with LINQ expression. // { // chosenVertices.Add(secondVertex.Position, secondVertex); // } // //var oddChosenVertices = chosenVertices.ToList().Where((c, i) => i % 2 != 0); // var evenChosenVertices = chosenVertices.ToList().Where((c, i) => i % 2 == 0).ToList(); // // secondVertex IS PART OF evenChosenVertices. // if (evenChosenVertices.Count > 1) // { // var mostRecentVertex = evenChosenVertices[evenChosenVertices.Count - 2]; // // use this position AND the mostRecentVertexPosition to get the corresponding edge. IT SHOULD EXIST. // // (But what if it was cut?) // // We must get the edge and choose it. // if (mostRecentVertex.Key != secondVertex.Position) // { // var visitedEdge = secondVertex.AdjacencyDirector.GetEdgeIncidentToBothVertices(secondVertex.Position, mostRecentVertex.Key); // visitedEdge.Choose(); // } // } // this.Visit(secondVertex); // var orphanedElements = secondVertex.DecideNext.Values; // //if (orphanedElements.Any()) // //{ // // ProcessOrphanedElements(secondVertex, orphanedElements.ToList()); // //} // //else // //{ // // var firstUnvisitedGroupList = GroupElementsByWeight(secondVertex); // // //vertexList = firstUnvisitedGroupList.Select(t => t.Value).ToList(); // //} // foreach (var adjacencyDirectableVisitable in orphanedElements) // Could be replaced with LINQ Except expression. // { // if (!chosenVertices.ContainsKey(adjacencyDirectableVisitable.Position)) // { // pendingVerticesToProcess.Add(adjacencyDirectableVisitable); // } // } // foreach (var nextVertex in pendingVerticesToProcess) // { // AlternateProcessing(firstVertex, nextVertex, chosenVertices.DeepClone(), counter); // } // } // } // if (firstVertex != null) // { // if (firstVertex.Position == 3) // { // Console.Write("?"); // } // } // foreach (var adjacencyDirectableVisitable in chosenVertices) // { // Console.Write(adjacencyDirectableVisitable.Key + ", "); // } // Console.WriteLine(); //} public void Walk( IAdjacencyDirectableVisitable originVertex) { var manTrail = new List <IAdjacencyDirectableVisitable>(); var womanTrail = new List <IAdjacencyDirectableVisitable>(); Walk(originVertex, originVertex, originVertex, manTrail, womanTrail, FirstStepTaken.No, 0); }
public WalkPath(IAdjacencyDirectableVisitable originVertex, IAdjacencyDirectableVisitable manCurrentVertex, IAdjacencyDirectableVisitable womanCurrentVertex, List <IAdjacencyDirectableVisitable> manTrail, List <IAdjacencyDirectableVisitable> womanTrail) { this.originVertex = originVertex; this.manCurrentVertex = manCurrentVertex; this.womanCurrentVertex = womanCurrentVertex; this.manTrail = manTrail; this.womanTrail = womanTrail; }
public void Cut(IAdjacencyDirectableVisitable adjacentVertexToCut) { adjacentVertexToCut.Weight -= this.Weight; if (adjacentVertexToCut.Weight < 0) { throw new AdjacencyException("The weight calculation is not valid! (Weight cannot be negative.)"); } this.AdjacencyDirector.Cut(this.Position, adjacentVertexToCut.Position); }
public void Register(IAdjacencyDirectableVisitable directableVisitable) { if (directableVisitable == null) { throw new NullReferenceException("Directable cannot be null when registering it with the AdjacencyMatrixDictionaryDirector!"); } this.VertexDataProvider.Add(directableVisitable.Position, directableVisitable); this.AdjacencyProvider.Add(directableVisitable.Position); this.IncidenceProvider.AddVertex(directableVisitable.Position); }
///// <summary> ///// This overloaded method determines which path to take. It also determines if there are any orphans. ///// </summary> ///// <param name="vertexToProcess"></param> ///// <returns></returns> //public List<IAdjacencyDirectableVisitable> DetermineWhichVertexToChoose(IAdjacencyDirectableVisitable vertexToProcess) //{ // return DetermineWhichVertexToChoose(vertexToProcess, null); //} ///// <summary> ///// This method determines which path to take. It also determines if there are any orphans. ///// This is the weighting system that only should choose an element if it does not orphan any other vertex. ///// So, I need a method that checks if choosing a given vertex will orphan any other vertex (due to the cuts involved). ///// This task would be best performed from the vertex, not the visitor! ///// </summary> ///// <param name="vertexToProcess"></param> ///// <param name="chosenVertices"></param> ///// <returns></returns> //[Obsolete("Warning: Needs to be fixed.")] //public List<IAdjacencyDirectableVisitable> DetermineWhichVertexToChoose(IAdjacencyDirectableVisitable vertexToProcess, // IDictionary<int, IAdjacencyDirectableVisitable> chosenVertices) //{ // if (chosenVertices == null) // { // chosenVertices = new Dictionary<int, IAdjacencyDirectableVisitable>(); // } // var groupedElements = GroupElementsByWeight(vertexToProcess); // //into g // //orderby g.Key ascending // var firstGroup = groupedElements.OrderBy(t => t.Key).FirstOrDefault(); // if (firstGroup == null)// We should only need to process the first one if our weights are perfect. // { // We need to cut the appropriate elements and update the weights. // throw new NullReferenceException("firstGroup cannot be null."); // } // var firstUnvisitedGroupList = firstGroup.Except(chosenVertices).ToList(); // // We need to inspect the chosenVertices. If we take the list of chosenVertices, we can slice it into two lists of consecutive elements. // // Then, it is clear which vertices need to be cut. // //if (chosenVertices.Count > 1) // //{ // // ? // // ; // // // We need a method that takes the chosenVertices, checks for sequences, and cuts unneeded adjacencent vertices. // //} // //from p in persons // // group p.car by p.PersonId into g // // select new { PersonID = g.Key, Cars = g.ToList() }; // var orphanedElements = new List<IAdjacencyDirectableVisitable>(); // var nonOrphanedElements = new List<IAdjacencyDirectableVisitable>(); // foreach (var adjacentElement in firstUnvisitedGroupList) // { // var doesCutOrphanVertex = this.DoesCutOrphanVertex(vertex1: vertexToProcess, vertex2: adjacentElement.Value); // if (doesCutOrphanVertex) // { // orphanedElements.Add(adjacentElement.Value); // } // else // { // nonOrphanedElements.Add(adjacentElement.Value); // } // // If not true, then we can add this pair to the set of items we can cut: vertexToProcess, adjacentElement.Value // } // return vertexToProcess.DecideNext.Values.ToList(); //} private static IEnumerable <IGrouping <int, KeyValuePair <int, IAdjacencyDirectableVisitable> > > GroupElementsByWeight( IAdjacencyDirectableVisitable vertexToProcess) { var director = vertexToProcess.AdjacencyDirector; var adjacentElements = vertexToProcess.DirectableList; // Filter adjacentElements to only those with equally lowest weight. var groupedElements = from e in adjacentElements group e by e.Value.Weight; return(groupedElements); }
// public abstract void Visit(Node<T> node, Action<T> action); // Should we have an actionableNodeVisitor and a functionalNodeVisitor as subtypes? Or will they all be actionable? /// <summary> /// Use the other overload. This visits the nodes to compute the weight. /// </summary> /// <param name="visitable">This is the node we wish to visit.</param> /// <param name="depth">The depth is intended to prevent infinite recursion.</param> /// <param name="positionQueue"></param> public void Visit(IAdjacencyDirectableVisitable visitable, int depth, Queue <int> positionQueue) { if (positionQueue == null || !positionQueue.Any()) // Indicates if this is the first visitation in the stack. { if (positionQueue == null) { positionQueue = new Queue <int>(); } visitable.Choose(); PerformCuts(visitable); } if (depth < 0) { throw new ArgumentOutOfRangeException("depth", "Visitor recursion depth cannot be negative!"); } // How do we check if this is the first execution? positionQueue.Enqueue(visitable.Position); //positionQueue.Enqueue(new Tuple<int, int>(visitable.Position, visitable.Weight)); // compute weights and get adjacent children. // for number of steps of counter, recursively get sum of childrens' weights. //_weight += visitable.Weight; //visitable.Weight = _counter - depth; depth++; //Console.WriteLine("Depth = {0}", depth); // Get current weight if (depth <= this._counter) // When depth > _counter, we have completed processing the adjacency tree for a given vertex. { var visitableItem = visitable.DecideNext; //var visitableItem = visitable.AdjacentDirectables // .Where(t => t.Key != visitable.Position); // This filter prevents containing the identity elements. foreach (var adjacentVertex in visitableItem) { //visitable.AdjacencyDirector.VertexDataProvider.Elements[adjacentVertex.Key].Weight += _counter - depth; var weight = _counter - depth; if (weight > 0) // i.e. There's no point to adding weight unless the weight is above 0 { adjacentVertex.Value.Weight += weight; } //Console.WriteLine("adjacentVertex.Key = {0}, weight = {1}, depth = {2}, counter = {3}, visitable.Position = {4}", // adjacentVertex.Key, adjacentVertex.Value.Weight, depth, _counter, visitable.Position); //foreach (var i in positionQueue) //{ // Console.WriteLine("Position: {0}",i); //} var clone = positionQueue.DeepClone(); _positionQueueList.Add(clone); adjacentVertex.Value.Accept(this, depth, clone); } } }
public bool IsEdgeChosen(IAdjacencyDirectableVisitable vertex1, IAdjacencyDirectableVisitable vertex2) { var incidentEdgeResult = IsEdgeChosen(vertex1.Position, vertex2.Position); if (incidentEdgeResult) { //if (!vertex1.Chosen || !vertex2.Chosen) //{ // throw new ChosenException(vertex1.Position, vertex2.Position, "Check VertexNode's IsEdgeChosen(..) method."); //} } return(incidentEdgeResult); }
private static void PerformCuts(IAdjacencyDirectableVisitable visitable) { foreach (var adjacencyDirectableVisitable in visitable.AdjacentChosenElements) // These are elements on the trail. { if (adjacencyDirectableVisitable.Value.ChosenEdges.Count == 2) // if the element has two edges that are on the trail. { foreach (var adjacentUnchosenElement in adjacencyDirectableVisitable.Value.UnchosenEdgesThatDontOrphanTargetVertex) { adjacencyDirectableVisitable.Value.Cut(adjacentUnchosenElement.Value); // Then cut any unused vertex. } } } }
//private static string ConstructPathID(IAdjacencyDirectableVisitable originVertex, // List<IAdjacencyDirectableVisitable> manTrail, List<IAdjacencyDirectableVisitable> womanTrail, // IAdjacencyDirectableVisitable man) //{ // var womanTrailPositions = womanTrail.Select(t => t.Position); // var womanTrailReverse = womanTrailPositions.Reverse(); // var allPositions = new List<int>((manTrail.Count + womanTrail.Count) * 3); // allPositions.Add(originVertex.Position); // foreach (var manItem in manTrail) // { // allPositions.Add(manItem.Position); // } // allPositions.Add(man.Position); // foreach (var womanPosition in womanTrailReverse) // skip the first because it should be the same as the last man. // { // allPositions.Add(womanPosition); // } // var sb = new StringBuilder((manTrail.Count + womanTrail.Count) * 3); // foreach (var item in allPositions) // { // sb.Append(item + ", "); // } // sb.Append(originVertex); //} private static void WritePathIDToConsoleFaster(IAdjacencyDirectableVisitable originVertex, List <IAdjacencyDirectableVisitable> manTrail, List <IAdjacencyDirectableVisitable> womanTrail, IAdjacencyDirectableVisitable man) { var womanTrailPositions = womanTrail.Select(t => t.Position); var womanTrailReverse = womanTrailPositions.Reverse(); var sb = new StringBuilder((manTrail.Count + womanTrail.Count) * 3); sb.Append(originVertex.Position + ", "); foreach (var manItem in manTrail) { sb.Append(manItem.Position + ", "); } sb.Append(man.Position + ", "); foreach (var womanPosition in womanTrailReverse) // skip the first because it should be the same as the last man. { sb.Append(womanPosition + ", "); } sb.Append(originVertex.Position); Console.WriteLine(sb.ToString()); }
/// <summary> /// This method could throw an error if the element already exists. /// </summary> /// <param name="position"></param> /// <param name="element"></param> public void Add(int position, IAdjacencyDirectableVisitable element) { this.Dictionary.Add(position, element); }
/// <summary> /// Use the other overload. /// </summary> /// <param name="visitable"></param> /// <param name="depth"></param> public void Visit(IAdjacencyDirectableVisitable visitable, int depth) { // This overload will not be called recursively, so it should have an accurate list of visited vertices. Visit(visitable, depth, null); }
/// <summary> /// Use this one. /// </summary> /// <param name="visitable"></param> public void Visit(IAdjacencyDirectableVisitable visitable) { Visit(visitable, 2, null); }
public void Walk( IAdjacencyDirectableVisitable originVertex, IAdjacencyDirectableVisitable manCurrentVertex, IAdjacencyDirectableVisitable womanCurrentVertex, List <IAdjacencyDirectableVisitable> manTrail, List <IAdjacencyDirectableVisitable> womanTrail, FirstStepTaken firstStepTaken, int depth) { depth++; if (firstStepTaken == FirstStepTaken.No) { // Then take first step. var firstStepVertices = originVertex.DecideNext.ToList(); var marriageList = new List <Tuple <IAdjacencyDirectableVisitable, IAdjacencyDirectableVisitable> >(); for (int i = 0; i < firstStepVertices.Count - 1; i++) { for (int j = 0; j < i; j++) { var man = firstStepVertices[i].Value; var woman = firstStepVertices[j].Value; if (man.Position != woman.Position) { var marriage = new Tuple <IAdjacencyDirectableVisitable, IAdjacencyDirectableVisitable>( man, woman); marriageList.Add(marriage); } foreach (var marriage in marriageList) { var manCopy = marriage.Item1.DeepClone(); var womanCopy = marriage.Item2.DeepClone(); var originVertexCopy = originVertex.DeepClone(); manCopy.Deregister(); // will this line screw everything up for the other objects? Not if we use a clone. womanCopy.Deregister(); originVertexCopy.AdjacencyDirector.Register(manCopy); originVertexCopy.AdjacencyDirector.Register(womanCopy); manTrail.Add(manCopy); womanTrail.Add(womanCopy); // create a method that allows me to Visit(originVertexCopy); Visit(manCopy); Visit(womanCopy); var manEdge = originVertexCopy.AdjacencyDirector.GetEdgeIncidentToBothVertices(manCopy.Position, originVertexCopy.Position); manEdge.Choose(); var womanEdge = originVertexCopy.AdjacencyDirector.GetEdgeIncidentToBothVertices(womanCopy.Position, originVertexCopy.Position); womanEdge.Choose(); Walk(originVertexCopy, manCopy, womanCopy, manTrail, womanTrail, FirstStepTaken.Yes, depth); } } } // marriageList should contain all unique pairs. } if (firstStepTaken == FirstStepTaken.Yes) { if (manTrail.Count >= 9) { Console.Write("Check"); } // Here is where we perform any cuts. var manAdjacentVertices = manCurrentVertex.UnchosenEdgesThatDontOrphanTargetVertex.ToList(); var womanAdjacentVertices = womanCurrentVertex.UnchosenEdgesThatDontOrphanTargetVertex.ToList(); var marriageList = new List <Tuple <IAdjacencyDirectableVisitable, IAdjacencyDirectableVisitable> >(); marriageList.Clear(); for (int i = 0; i < manAdjacentVertices.Count; i++) { for (int j = 0; j < womanAdjacentVertices.Count; j++) { var man = manAdjacentVertices[i].Value; var woman = womanAdjacentVertices[j].Value; if (man.Position != woman.Position) { var manTrailContainsMan = manTrail.Any(t => t.Position == man.Position); var womanTrailContainsWoman = womanTrail.Any(t => t.Position == woman.Position); var manTrailContainsWoman = manTrail.Any(t => t.Position == woman.Position); var womanTrailContainsMan = womanTrail.Any(t => t.Position == man.Position); if (!manTrailContainsMan && !womanTrailContainsWoman && !manTrailContainsWoman && !womanTrailContainsMan) { var marriage = new Tuple <IAdjacencyDirectableVisitable, IAdjacencyDirectableVisitable>( man, woman); marriageList.Add(marriage); } } else // In this case, because both man and woman have reached the same vertex, we have the closure of a cycle. { Console.WriteLine("Closure on vertex {0}", man.Position); // note: man.Position == woman.Position in this case. // Then we should write the members of the two trails to the console, like this: // womanTrailReverse = womanTrail.Reverse(); // originVertex, manTrail[0], manTrail[1], ..., manTrail[n], man.Position, womanTrailReverse[0], womanTrailReverse[1], ..., // womanTrailReverse[m]. //WritePathIDToConsole(originVertex, manTrail, womanTrail, man); WritePathIDToConsoleFaster(originVertex, manTrail, womanTrail, man); } } } //foreach (var marriage in marriageList) //{ Parallel.ForEach(marriageList, marriage => { var manTrailCopy = manTrail.DeepClone(); // We must clone the trail here in the foreach loop to ensure we operate on the correct values. var womanTrailCopy = womanTrail.DeepClone(); var man = marriage.Item1; var woman = marriage.Item2; var manTrailContainsMan = manTrailCopy.Any(t => t.Position == man.Position); var womanTrailContainsWoman = womanTrailCopy.Any(t => t.Position == woman.Position); var manTrailContainsWoman = manTrailCopy.Any(t => t.Position == woman.Position); var womanTrailContainsMan = womanTrailCopy.Any(t => t.Position == man.Position); if (!manTrailContainsMan && !womanTrailContainsWoman && !manTrailContainsWoman && !womanTrailContainsMan) { var manCopy = marriage.Item1.DeepClone(); var womanCopy = marriage.Item2.DeepClone(); var originVertexCopy = originVertex.DeepClone(); manCopy.Deregister(); // will this line screw everything up for the other objects? Not if we use a clone. womanCopy.Deregister(); originVertexCopy.AdjacencyDirector.Register(manCopy); originVertexCopy.AdjacencyDirector.Register(womanCopy); manTrailCopy.Add(manCopy); womanTrailCopy.Add(womanCopy); // create a method that allows me to //Visit(originVertexCopy); // Using the director on originVertexCopy, I need to get the edge between // manCopy and the most recent item in manTrail // I need to either cut or choose. var previousMan = manTrailCopy[manTrailCopy.Count - 2]; var previousWoman = womanTrailCopy[womanTrailCopy.Count - 2]; var manEdge = originVertexCopy.AdjacencyDirector.GetEdgeIncidentToBothVertices(manCopy.Position, previousMan.Position); manEdge.Choose(); var womanEdge = originVertexCopy.AdjacencyDirector.GetEdgeIncidentToBothVertices(womanCopy.Position, previousWoman.Position); womanEdge.Choose(); previousMan.Deregister(); // I must reregister previousMan and previousWoman to use the originVertexCopy.AdjacencyDirector originVertexCopy.AdjacencyDirector.Register(previousMan); // to ensure that queries/cuts performed by previousMan/previousWoman affect the correct data. previousWoman.Deregister(); originVertexCopy.AdjacencyDirector.Register(previousWoman); // I need to determine which edges to cut. // I can get the vertices that previousMan is adjacent to, filter them to the ones that do not have a chosen edge, // At this moment, the visitor's Visit(..) method is responsible for performing cuts. //previousMan.ChosenEdges // previousMan.UnchosenEdgesThatDontOrphanTargetVertex // Once a vertex is incident to two chosen edges, then any remaining unchosen edges may be cut. var previousManElementsToCut = previousMan.UnchosenEdgesWithUnchosenVertices; // and cut those edges. (This works Visit(manCopy); Visit(womanCopy); //var finalPositionsAreAdjacent = originVertexCopy.AdjacencyDirector.AdjacencyProvider.AreVerticesBothAdjacent( // manCopy.Position, womanCopy.Position); //if (finalPositionsAreAdjacent) //{ // Console.Write("Yay!"); //} ////Console.WriteLine("Control returned, counts are: {0} and {1}", manTrailCopy.Count, //// womanTrailCopy.Count); //var sb = new StringBuilder(); //sb.AppendLine("Men are: "); //foreach (var manElement in manTrailCopy) //{ // sb.Append(manElement.Position + ", "); //} //sb.Append(" Women are: "); //foreach (var womanElement in womanTrailCopy) //{ // sb.Append(womanElement.Position + ", "); //} //Console.WriteLine(sb.ToString()); //if (manTrailCopy.Count >= 9) //{ // var finalPositionsAreAdjacent = originVertexCopy.AdjacencyDirector.AdjacencyProvider.AreVerticesBothAdjacent( // manCopy.Position, womanCopy.Position); // if (finalPositionsAreAdjacent) // { // Console.Write("Yay!"); // } // //Console.WriteLine("Control returned, counts are: {0} and {1}", manTrailCopy.Count, // // womanTrailCopy.Count); // var sb = new StringBuilder(); // sb.AppendLine("Men are: "); // foreach (var manElement in manTrailCopy) // { // sb.Append(manElement.Position + ", "); // } // sb.Append(" Women are: "); // foreach (var womanElement in womanTrailCopy) // { // sb.Append(womanElement.Position + ", "); // } // Console.WriteLine(sb.ToString()); // // It would be good to check which of these have the last two vertices as adjacent. //} Walk(originVertexCopy, manCopy, womanCopy, manTrailCopy, womanTrailCopy, FirstStepTaken.Yes, depth); //Console.WriteLine("Control returned, counts are: {0} and {1}", manTrailCopy.Count, // womanTrailCopy.Count); } }); //} } }
public bool WasVertexVisited(IAdjacencyDirectableVisitable vertex, IDictionary <int, IAdjacencyDirectableVisitable> visitedVertices) { return(visitedVertices.ContainsKey(vertex.Position)); }
public void Cut(IAdjacencyDirectableVisitable vertex1, IAdjacencyDirectableVisitable vertex2) { Cut(vertex1.Position, vertex2.Position); }
public void Deregister(IAdjacencyDirectableVisitable directableVisitable) { throw new NotImplementedException(); }
public bool DoesCutOrphanVertex(IAdjacencyDirectableVisitable vertex1, IAdjacencyDirectableVisitable vertex2) { return(vertex1.AdjacencyDirector.DoesCutOrphanVertex(vertex1.Position, vertex2.Position)); }
/// <summary> /// This method could throw an error if the element doesn't exist yet. /// </summary> /// <param name="position"></param> /// <param name="element"></param> public void Update(int position, IAdjacencyDirectableVisitable element) { this.Dictionary[position] = element; }
public bool DoesCutOrphanVertex(IAdjacencyDirectableVisitable vertexTarget) { return(this.AdjacencyDirector.DoesCutOrphanVertex(this.Position, vertexTarget.Position)); }