private void MakeA()
{
var graph = AuxStack.Pop();
var firstNode = CreateNode();
var secondNode = CreateNode();
var finalNode = CreateNode();
var pathToFirst = CreatePath(null, firstNode);
var pathToSecond = CreatePath(firstNode, secondNode);
// path to third
graph.Item1.NodeFrom = secondNode;
// path to final
graph.Item2.NodeTo = finalNode;
var finalPath = CreatePath(finalNode, null);
var edgeFirstToLast = CreatePath(firstNode, finalNode);
var pathToBackSecond = CreatePath(graph.Item2.NodeFrom, secondNode);
var resultGraph = new Tuple <Edge, Edge>(pathToFirst, finalPath);
AuxStack.Push(resultGraph);
}
private void MakeAdd()
{
var secondItem = AuxStack.Pop();
var firstItem = AuxStack.Pop();
var andStartNode = CreateNode();
var andEndNode = CreateNode();
// Conectar o novo node ao começo do primeiro elemento
firstItem.Item1.NodeFrom = andStartNode;
// Cria node intermediario para ligar o primeiro com o segundo
var interNode = CreateNode();
firstItem.Item2.NodeTo = interNode;
secondItem.Item1.NodeFrom = interNode;
secondItem.Item2.NodeTo = andEndNode;
// criar edges das pontas
var startEdge = CreatePath(null, andStartNode);
var endEdge = CreatePath(andEndNode, null);
var resultGraph = new Tuple <Edge, Edge>(startEdge, endEdge);
AuxStack.Push(resultGraph);
}
public void MakeT()
{
var lastExpression = AuxStack.Pop();
MakeExpression(lastExpression.Item1.NodeTo.Value);
AuxStack.Push(lastExpression);
MakeA();
MakeAdd();
}
private void MakeExpression(char c)
{
var node = CreateNode(c);
var edgeNullToNode = CreatePath(null, node, node.Value);
var edgeNodeToNull = CreatePath(node, null);
AuxStack.Push(new Tuple <Edge, Edge>(edgeNullToNode, edgeNodeToNull));
}
private void ExecuteStartCommand()
{
BeginStack.Clear();
AuxStack.Clear();
EndStack.Clear();
IsSolved = false;
InitPushIntoBeginStack();
PegState = SourcePegState.BEGIN;
UpdateCollectionAsync();
SolveTowersOfHanoi();
}
async Task UpdateCollectionAsync()
{
Task t = Task.Delay(3000);
BeginCollection.Clear();
AuxCollection.Clear();
EndCollection.Clear();
BeginStack.ToList().ForEach((x) => BeginCollection.Add(x));
AuxStack.ToList().ForEach((x) => AuxCollection.Add(x));
EndStack.ToList().ForEach((x) => EndCollection.Add(x));
await t;
}
private void MakeUnion()
{
var graphA = AuxStack.Pop();
var graphB = AuxStack.Pop();
// cria os dois nós que vão se ligar com
// o inicio da união e com os nós das expressões
// que estão na operação
var nodeAUnion = CreateNode();
var nodeBUnion = CreateNode();
// cria o primeiro nó da união
var unionStartNode = CreateNode();
// cria os edges entre o nó da união + os
// dois das laterais
var edgeUnionToNodeAUnion = CreatePath(unionStartNode, nodeAUnion);
var edgeUnionToNodeBUnion = CreatePath(unionStartNode, nodeBUnion);
// conecta os nós originais ao nodeAunion e nodeBunion
graphA.Item1.NodeFrom = nodeAUnion;
graphB.Item1.NodeFrom = nodeBUnion;
// Conectar o node ao final dos elemts.
var unionEndNode = CreateNode();
graphA.Item2.NodeTo = unionEndNode;
graphB.Item2.NodeTo = unionEndNode;
// Criar um novo edge inicial
var edgeInitalToStart = CreatePath(null, unionStartNode);
// Criar um novo edge final
var edgeFinalToEnd = CreatePath(unionEndNode, null);
var resultGraph = new Tuple <Edge, Edge>(edgeInitalToStart, edgeFinalToEnd);
AuxStack.Push(resultGraph);
}
async Task SolveTowersOfHanoi()
{
if (IsSolved)
{
return;
}
await UpdateCollectionAsync();
//Done State
if (EndStack.Count == INIT_DISK_LEN)
{
IsSolved = true;
return;
}
switch (PegState)
{
case SourcePegState.BEGIN:
// END , AUX
if (BeginStack.Count > 0)
{
if (EndStack.Count == 0 || CanPush(BeginStack.Peek(), EndStack.Peek()))
{
EndStack.Push(BeginStack.Pop());
SolveTowersOfHanoi();
}
else if (AuxStack.Count == 0 || CanPush(BeginStack.Peek(), AuxStack.Peek()))
{
AuxStack.Push(BeginStack.Pop());
//PegState = SourcePegState.BEGIN;
SolveTowersOfHanoi();
}
else
{
PegState = SourcePegState.END;
SolveTowersOfHanoi();
}
}
else
{
PegState = SourcePegState.END;
SolveTowersOfHanoi();
}
break;
case SourcePegState.AUXILLARY:
// BEGIN, END
if (AuxStack.Count > 0)
{
if (BeginStack.Count == 0 || CanPush(AuxStack.Peek(), BeginStack.Peek()))
{
BeginStack.Push(AuxStack.Pop());
SolveTowersOfHanoi();
}
else if (EndStack.Count == 0 || CanPush(AuxStack.Peek(), EndStack.Peek()))
{
EndStack.Push(AuxStack.Pop());
SolveTowersOfHanoi();
}
else
{
PegState = SourcePegState.BEGIN;
SolveTowersOfHanoi();
}
}
else
{
PegState = SourcePegState.BEGIN;
SolveTowersOfHanoi();
}
break;
case SourcePegState.END:
//Lock State
if (EndStack.Count > 0)
{
//max elem
if (EndStack.Peek() == 3) //&& EndStack.Count == 1)
{
//state transition to Aux
PegState = SourcePegState.AUXILLARY;
SolveTowersOfHanoi();
return;
}
}
//AUX, BEGIN
if (EndStack.Count > 0)
{
if (AuxStack.Count == 0 || CanPush(EndStack.Peek(), AuxStack.Peek()))
{
AuxStack.Push(EndStack.Pop());
SolveTowersOfHanoi();
}
else if (BeginStack.Count == 0 || CanPush(EndStack.Peek(), BeginStack.Peek()))
{
BeginStack.Push(EndStack.Pop());
SolveTowersOfHanoi();
}
else
{
PegState = SourcePegState.BEGIN;
SolveTowersOfHanoi();
}
}
else
{
PegState = SourcePegState.BEGIN;
SolveTowersOfHanoi();
}
break;
default:
break;
}
}
