public void SearchContactsTest()
{
//
// digraph G {
// "7" -> "11"
// "7" -> "8"
// "5" -> "11"
// "3" -> "8"
// "3" -> "10"
// "11" -> "2"
// "11" -> "9"
// "11" -> "10"
// "8" -> "9"
// }
var ret = TopologicalSort.Sort(
new HashSet <int>(new[] { 1, 7, 5, 3, 8, 11, 2, 9, 10, 2 }),
new HashSet <Tuple <int, int> >(
new[] {
Tuple.Create(7, 11),
Tuple.Create(7, 8),
Tuple.Create(5, 11),
Tuple.Create(3, 8),
Tuple.Create(3, 10),
Tuple.Create(11, 2),
Tuple.Create(11, 9),
Tuple.Create(11, 10),
Tuple.Create(8, 9)
}
)
).ToList();
System.Diagnostics.Debug.Assert(ret.SequenceEqual(new[] { 1, 7, 5, 11, 2, 3, 8, 9, 10 }));
}
public static Queue <MyInfo> PerformTopoSort(List <MyInfo> nodes)
{
var sorter = new TopologicalSort <MyInfo>();
Queue <MyInfo> outQueue;
foreach (var myInfo in nodes.Where(n => n.Checked))
{
if (myInfo.Dependencies.Any())
{
foreach (var dependency in myInfo.Dependencies)
{
if (myInfo.Equals(dependency))
{
throw new Exception("Cyclic Dependency detected from '" + dependency + "' to '" + myInfo + "'");
}
sorter.Edge(myInfo, dependency);
}
}
else
{
sorter.Edge(myInfo);
}
}
sorter.Sort(out outQueue);
return(outQueue);
}
public void DoImport(Stream backupStream, Action <ExportImportProgressInfo> progressCallback)
{
var progressInfo = new ExportImportProgressInfo();
var membersTotalCount = 0;
using (var streamReader = new StreamReader(backupStream))
using (var reader = new JsonTextReader(streamReader))
{
while (reader.Read())
{
if (reader.TokenType == JsonToken.PropertyName)
{
if (reader.Value.ToString() == "MembersTotalCount")
{
membersTotalCount = reader.ReadAsInt32() ?? 0;
}
else if (reader.Value.ToString() == "Members")
{
reader.Read();
if (reader.TokenType == JsonToken.StartArray)
{
reader.Read();
var members = new List <Member>();
var membersCount = 0;
//TODO: implement to iterative import without whole members loading
while (reader.TokenType != JsonToken.EndArray)
{
var member = _serializer.Deserialize <Member>(reader);
members.Add(member);
membersCount++;
reader.Read();
}
//Need to import by topological sort order, because Organizations have a graph structure and here references integrity must be preserved
var organizations = members.OfType <Organization>();
var nodes = new HashSet <string>(organizations.Select(x => x.Id));
var edges = new HashSet <Tuple <string, string> >(organizations.Where(x => !string.IsNullOrEmpty(x.ParentId)).Select(x => new Tuple <string, string>(x.Id, x.ParentId)));
var orgsTopologicalSortedList = TopologicalSort.Sort(nodes, edges);
members = members.OrderByDescending(x => orgsTopologicalSortedList.IndexOf(x.Id)).ToList();
for (int i = 0; i < membersCount; i += _batchSize)
{
_memberService.SaveChanges(members.Skip(i).Take(_batchSize).ToArray());
if (membersTotalCount > 0)
{
progressInfo.Description = $"{ i } of { membersTotalCount } members imported";
}
else
{
progressInfo.Description = $"{ i } members imported";
}
progressCallback(progressInfo);
}
}
}
}
}
}
}
/// <summary>
/// Calculate all cells in spreadsheet.
/// </summary>
/// <exception cref="SpreadsheetInternalException">Cyclic dependency found.</exception>
public void Calculate()
{
IList <string> sortedKeys;
try
{
sortedKeys = TopologicalSort.Sort(
GetAllKeys(),
key => GetCellByKey(key).CellDependencies.Where(d => CellInSpreadsheet(d))
);
}
catch (CyclicDependencyException exception)
{
throw new SpreadsheetInternalException($"Cannot calculate spreadsheet, there is cyclic dependencies between cells. {exception.Message}", exception);
}
foreach (var key in sortedKeys)
{
CalculateCell(GetCellByKey(key));
}
// Validate that all cells were calculated.
foreach (var key in GetAllKeys())
{
if (GetCellByKey(key).CellState == CellState.Pending)
{
throw new SpreadsheetInternalException($"The cell {key} was lost during the calculation.");
}
}
}
public void Process(Configurator configurator, bool runAsCoroutine = true)
{
if (configurator != null)
{
m_configurator = configurator;
}
Logger.LogDebug(this, "Starting to run init actions", Logger.TagFlags.INIT);
ValidateDependencies();
List <ITopologicalNode> list = new List <ITopologicalNode>();
list = m_initActions.ConvertAll((Converter <InitAction, ITopologicalNode>)((InitAction obj) => obj));
list = TopologicalSort.Sort(list);
m_initActions = list.ConvertAll((ITopologicalNode obj) => obj as InitAction);
EventDispatcher.AddListener <ActionCompleteEvent>(OnInitActionComplete);
EventDispatcher.DispatchEvent(new InitStartEvent(InitActions.Count));
if (CheckAllComplete())
{
OnAllInitComplete();
return;
}
m_runAsCoroutine = runAsCoroutine;
if (m_runAsCoroutine)
{
BaseGameController.Instance.StartCoroutine(ExecuteReadyActionsCoroutine());
}
else
{
CoroutineHelper.RunCoroutineToCompletion(ExecuteReadyActionsCoroutine());
}
}
public void Test()
{
var graph1 = new DirectedWeightedGraph(false);
for (int i = 'a'; i <= 'h'; i++)
{
graph1.AddVertex(Convert.ToString(Convert.ToChar(i)));
}
graph1.AddEdge("a", "b", 1);
graph1.AddEdge("b", "c", 2);
graph1.AddEdge("c", "d", 3);
graph1.AddEdge("a", "g", 600);
graph1.AddEdge("b", "f", 0);
graph1.AddEdge("e", "b", 7);
Stack <Vertex> stack = new Stack <Vertex>();
stack.Push(graph1.GetVertex("d"));
stack.Push(graph1.GetVertex("c"));
stack.Push(graph1.GetVertex("f"));
stack.Push(graph1.GetVertex("b"));
stack.Push(graph1.GetVertex("g"));
stack.Push(graph1.GetVertex("a"));
stack.Push(graph1.GetVertex("e"));
stack.Push(graph1.GetVertex("h"));
var testStack = TopologicalSort <DirectedWeightedGraph> .Sort(graph1);
for (int i = 'a'; i <= 'h'; i++)
{
Assert.AreEqual(stack.Pop(), testStack.Pop());
}
}
public void Process(bool runAsCoroutine = true, MonoBehaviour coroutineOwner = null)
{
m_coroutineOwner = coroutineOwner;
ValidateDependencies();
List <ITopologicalNode> list = new List <ITopologicalNode>();
list = m_initActions.ConvertAll((Converter <InitAction, ITopologicalNode>)((InitAction obj) => obj));
list.AddRange(m_completedActions.ConvertAll((Converter <CompletedInitAction, ITopologicalNode>)((CompletedInitAction obj) => obj)));
list = TopologicalSort.Sort(list);
list.RemoveAll((ITopologicalNode obj) => obj is CompletedInitAction);
m_initActions = list.ConvertAll((ITopologicalNode obj) => obj as InitAction);
EventDispatcher.AddListener <ActionCompleteEvent>(OnInitActionComplete);
EventDispatcher.DispatchEvent(new InitStartEvent(InitActions.Count));
if (CheckAllComplete())
{
OnAllInitComplete();
return;
}
m_runAsCoroutine = runAsCoroutine;
if (m_runAsCoroutine)
{
m_coroutineOwner.StartCoroutine(ExecuteReadyActionsCoroutine());
}
else
{
CoroutineHelper.RunCoroutineToCompletion(ExecuteReadyActionsCoroutine());
}
}
public List <string> GetTableOrderByDependencies()
{
//Chứa cặp các table và các dependency của chúng
Dictionary <string, Item> existedAdj = new Dictionary <string, Item>();
List <Item> graphTableDependency = new List <Item>();
List <string> tables = _dbUtilities.GetAllTable();
foreach (var table in tables)
{
List <Item> adjTableDenpendencies = new List <Item>();
//List các table dependency của table
var dependencies = _dbUtilities.GetAllTableDependOn(table).ToArray();
foreach (var dependency in dependencies)
{
if (!table.Equals(dependency)) //Kiểm tra có phải là chính nó
{
if (!existedAdj.ContainsKey(dependency)) //Kiểm tra là đã tạo Item này chưa
{
var item = new Item(dependency);
existedAdj.Add(item.Name, item);
}
adjTableDenpendencies.Add(existedAdj[dependency]); //Tạo mới cạnh
}
}
//Tạo mới đỉnh là table các cạch là adjTableDenpendencies
graphTableDependency.Add(new Item(table, adjTableDenpendencies.ToArray()));
}
return(TopologicalSort.Sort(graphTableDependency.ToArray(), x => x.Dependencies));
}
private void SortDependencyGraph()
{
OnProgress("Sorting dependency graph");
var sort = new TopologicalSort <CodeUnit>(_rootUnit, parent => parent.Dependencies);
_orderedUnitList = sort.Sort();
}
public static IEnumerable <Step <TCtx> > OrderRequiredFirst(DependencyGraphBuilder <Step <TCtx> > _graphBuilder, IEnumerable <Step <TCtx> > steps)
{
var sort = new TopologicalSort <Step <TCtx> >();
var unsorted = steps.ToList();
var edges = _graphBuilder.BuildDependencyGraph(unsorted).ToArray();
return(sort.Sort(unsorted.ToList(), edges));
}
private void CalculateReachableBlocks()
{
_reachableBlocks = new Dictionary <BasicBlock, HashSet <BasicBlock> >();
foreach (var block in TopologicalSort.Sort(_basicBlocks, p => p.ExitBlocks, ignoreCycles: true))
{
_reachableBlocks[block] = CalculateReachableBlocks(block, new HashSet <BasicBlock>());
}
}
public void TopoTest_One()
{
TopologicalSort.Node node = new TopologicalSort.Node();
List <TopologicalSort.Node> nodes = new List <TopologicalSort.Node> {
node
};
List <TopologicalSort.Node> sortedNodes = TopologicalSort.Sort(nodes);
Assert.AreEqual(sortedNodes[0], nodes[0]);
}
public void Sort_DirectedGraphWithoutEdges_NothingToSort()
{
Dictionary <string, string[]> mock = new Dictionary <string, string[]>();
mock.Add("A", new string[0]);
mock.Add("B", new string[0]);
mock.Add("C", new string[0]);
var graphWithoutEdges = new[] { "A", "B", "C" };
Assert.Equal(graphWithoutEdges, TopologicalSort.Sort(graphWithoutEdges, item => mock[item]));
}
public void Test_Topological_Sorting()
{
var edgeList = new int[3][];
edgeList[0] = new int[] { 1, 2 };
edgeList[1] = new int[] { 2, 3 };
edgeList[2] = new int[] { 3, 4 };
var graph = Graph.BuildDirectedGraph(edgeList);
var topologicalSort = new TopologicalSort(4, graph);
Assert.Equal(new int[] { 4, 3, 2, 1 }, topologicalSort.Sort());
}
public void TopoTest_Circular()
{
TopologicalSort.Node a = new TopologicalSort.Node();
TopologicalSort.Node b = new TopologicalSort.Node();
a.Dependencies.Add(b);
b.Dependencies.Add(a);
List <TopologicalSort.Node> nodes = new List <TopologicalSort.Node> {
a, b
};
// ReSharper disable once UnusedVariable
List <TopologicalSort.Node> sortedNodes = TopologicalSort.Sort(nodes);
}
public void TopoTest_NoDependencies()
{
TopologicalSort.Node a = new TopologicalSort.Node();
TopologicalSort.Node b = new TopologicalSort.Node();
List <TopologicalSort.Node> nodes = new List <TopologicalSort.Node> {
a, b
};
List <TopologicalSort.Node> sortedNodes = TopologicalSort.Sort(nodes);
Assert.IsTrue(sortedNodes.Contains(a));
Assert.IsTrue(sortedNodes.Contains(b));
}
/// <summary>
/// Reorders Any WixSearch items.
/// </summary>
/// <param name="output">Output containing the tables to process.</param>
private void ReorderWixSearch(Output output)
{
Table wixSearchTable = output.Tables["WixSearch"];
if (null == wixSearchTable || wixSearchTable.Rows.Count == 0)
{
// nothing to do!
return;
}
RowDictionary rowDictionary = new RowDictionary();
foreach (Row row in wixSearchTable.Rows)
{
rowDictionary.AddRow(row);
}
Constraints constraints = new Constraints();
Table wixSearchRelationTable = output.Tables["WixSearchRelation"];
if (null != wixSearchRelationTable && wixSearchRelationTable.Rows.Count > 0)
{
// add relational info to our data...
foreach (Row row in wixSearchRelationTable.Rows)
{
constraints.AddConstraint((string)row[0], (string)row[1]);
}
}
this.FindCircularReference(constraints);
if (this.Core.EncounteredError)
{
return;
}
this.FlattenDependentReferences(constraints);
// Reorder by topographical sort (http://en.wikipedia.org/wiki/Topological_sorting)
// We use a variation of Kahn (1962) algorithm as described in
// Wikipedia, with the additional criteria that start nodes are sorted
// lexicographically at each step to ensure a deterministic ordering
// based on 'after' dependencies and ID.
TopologicalSort sorter = new TopologicalSort();
List <string> sortedIds = sorter.Sort(rowDictionary.Keys, constraints);
// Now, re-write the table with the searches in order...
wixSearchTable.Rows.Clear();
foreach (string id in sortedIds)
{
wixSearchTable.Rows.Add(rowDictionary[id]);
}
}
public List <IStrategyResult> ExecuteQueuedActions()
{
var results = new List <IStrategyResult>();
var actions = this.queuedActions.AsQueryable();
var sortedActions = TopologicalSort.Sort(actions, action => action.Dependencies, action => action.Name);
foreach (var strategyAction in sortedActions)
{
this.queuedActions.Remove(strategyAction);
results.Add(Execute(strategyAction.Name));
}
return(results);
}
public static void UpdateSorting()
{
FilterListByVisibility(staticSpriteList, currentlyVisibleStaticSpriteList);
FilterListByVisibility(moveableSpriteList, currentlyVisibleMoveableSpriteList);
ClearMovingDependencies(currentlyVisibleStaticSpriteList);
ClearMovingDependencies(currentlyVisibleMoveableSpriteList);
AddMovingDependencies(currentlyVisibleMoveableSpriteList, currentlyVisibleStaticSpriteList);
sortedSprites.Clear();
TopologicalSort.Sort(currentlyVisibleStaticSpriteList, currentlyVisibleMoveableSpriteList, sortedSprites);
SetSortOrderBasedOnListOrder(sortedSprites);
}
public void Test_Topological_Sorting_multiple_prerequisites()
{
var edgeList = new int[5][];
edgeList[0] = new[] { 1, 2 };
edgeList[1] = new[] { 2, 3 };
edgeList[2] = new[] { 2, 5 };
edgeList[3] = new[] { 3, 4 };
edgeList[4] = new[] { 5, 6 };
var graph = Graph.BuildDirectedGraph(edgeList);
var topologicalSort = new TopologicalSort(6, graph);
Assert.Equal(new int[] { 4, 3, 6, 5, 2, 1 }, topologicalSort.Sort());
}
public void Sort_TrivialDirectedGraph_GraphSorted()
{
Dictionary <string, string[]> mock = new Dictionary <string, string[]>();
mock.Add("A", new string[0]);
mock.Add("B", new[] { "A" });
mock.Add("C", new[] { "B" });
mock.Add("D", new[] { "C" });
var unsorted = new[] { "D", "C", "B", "A" };
var expected = new[] { "A", "B", "C", "D" };
Assert.Equal(expected, TopologicalSort.Sort(unsorted, item => mock[item]));
}
public void TopoTest_Two()
{
TopologicalSort.Node a = new TopologicalSort.Node();
TopologicalSort.Node b = new TopologicalSort.Node();
a.Dependencies.Add(b);
List <TopologicalSort.Node> nodes = new List <TopologicalSort.Node> {
a, b
};
List <TopologicalSort.Node> sortedNodes = TopologicalSort.Sort(nodes);
Assert.AreEqual(sortedNodes[0], b);
Assert.AreEqual(sortedNodes[1], a);
}
public void SortTest()
{
var graph = TestHelper.CreateSampleGraph();
var sut = new TopologicalSort <int>();
var iterator = new DepthFirstSearchIterator <int>(graph, 0);
var actual = sut.Sort(iterator);
var sortedVertices = actual.Select(x => x.Vertice).ToList();
var expected = new int[] { 0, 1, 3, 2, 4 };
CollectionAssert.AreEqual(expected, sortedVertices);
}
public void Execute()
{
this.ExtensionSearchSymbolsByExtensionId = new Dictionary <string, IList <IntermediateSymbol> >();
this.OrderedSearchFacades = new List <ISearchFacade>();
var searchRelationSymbols = this.Section.Symbols.OfType <WixSearchRelationSymbol>().ToList();
var searchSymbols = this.Section.Symbols.OfType <WixSearchSymbol>().ToList();
if (searchSymbols.Count == 0)
{
// nothing to do!
return;
}
var symbolDictionary = searchSymbols.ToDictionary(t => t.Id.Id);
var constraints = new Constraints();
if (searchRelationSymbols.Count > 0)
{
// add relational info to our data...
foreach (var searchRelationSymbol in searchRelationSymbols)
{
constraints.AddConstraint(searchRelationSymbol.Id.Id, searchRelationSymbol.ParentSearchRef);
}
}
this.FindCircularReference(constraints);
if (this.Messaging.EncounteredError)
{
return;
}
this.FlattenDependentReferences(constraints);
// Reorder by topographical sort (http://en.wikipedia.org/wiki/Topological_sorting)
// We use a variation of Kahn (1962) algorithm as described in
// Wikipedia, with the additional criteria that start nodes are sorted
// lexicographically at each step to ensure a deterministic ordering
// based on 'after' dependencies and ID.
var sorter = new TopologicalSort();
var sortedIds = sorter.Sort(symbolDictionary.Keys, constraints);
// Now, create the search facades with the searches in order...
this.OrderSearches(sortedIds, symbolDictionary);
}
public void Sort_DirectedGraphWithCyclicDependency_ThrowCyclicDependencyException()
{
Dictionary <string, string[]> mock = new Dictionary <string, string[]>();
mock.Add("A", new string[0]);
mock.Add("B", new[] { "C", "E" });
mock.Add("C", new string[0]);
mock.Add("D", new[] { "A" });
mock.Add("E", new[] { "D", "G" }); //Cyclic Dependency: E -> G -> F -> E
mock.Add("F", new[] { "E" });
mock.Add("G", new[] { "F", "H" });
mock.Add("H", new string[0]);
var unsorted = new[] { "A", "B", "C", "D", "E", "F", "G", "H" };
Assert.Throws <CyclicDependencyException>(() => TopologicalSort.Sort(unsorted, item => mock[item]));
}
public StronglyConnectedComponents(DirectedGraph g)
{
this.G = g;
id = new int[G.GetVertices()];
visited = new bool[G.GetVertices()];
count = 1;
TopologicalSort tpsort = new TopologicalSort(G);
foreach (var vertex in tpsort.Sort())
{
if (!visited[vertex])
{
Dfs(G, vertex);
++count;
}
}
}
public void TopoTest_Multiple()
{
TopologicalSort.Node a = new TopologicalSort.Node();
TopologicalSort.Node b = new TopologicalSort.Node();
TopologicalSort.Node c = new TopologicalSort.Node();
TopologicalSort.Node d = new TopologicalSort.Node();
a.Dependencies.Add(b);
a.Dependencies.Add(c);
b.Dependencies.Add(d);
List <TopologicalSort.Node> nodes = new List <TopologicalSort.Node> {
a, b, c, d
};
List <TopologicalSort.Node> sortedNodes = TopologicalSort.Sort(nodes);
Assert.IsTrue(sortedNodes.IndexOf(d) < sortedNodes.IndexOf(b));
Assert.IsTrue(sortedNodes.IndexOf(b) < sortedNodes.IndexOf(a));
Assert.IsTrue(sortedNodes.IndexOf(c) < sortedNodes.IndexOf(a));
}
public void TopSort_SortItems_ReturnResult()
{
var a = new Item("A");
var b = new Item("B", "C", "E");
var c = new Item("C");
var d = new Item("D", "A");
var e = new Item("E", "D", "G");
var f = new Item("F");
var g = new Item("G", "F", "H");
var h = new Item("H");
var unsorted = new[] { a, b, c, d, e, f, g, h };
var expected = "ACDFHGEB";
var sortedItems = TopologicalSort.Sort(unsorted, x => x.Dependencies, x => x.Name);
var data = sortedItems.Aggregate("", (current, group) => current + group.Name);
data.Should().Be(expected);
}
public static void Main()
{
var ts = new TopologicalSort<char>();
Queue<char> outQueue;
PriorityQueue<char> res= new PriorityQueue<char>();
bool returnValue;
int n = int.Parse(Console.ReadLine());
for (int i = 0; i < n; i++)
{
char[] l = Console.ReadLine().ToCharArray();
foreach (var p in l)
{
res.Enqueue(p);
}
for (int j = 0; j < l.Length-1; j++)
{
ts.Edge(l[j+1], l[j]);
}
}
returnValue = ts.Sort(out outQueue);
StringBuilder result = new StringBuilder();
if (outQueue.Count == 0)
{
StringBuilder m = new StringBuilder();
while (res.Count != 0)
{
m.Append(res.Dequeue());
}
Console.WriteLine(m);
return;
}
while (outQueue.Count != 0)
result.Append(outQueue.Dequeue());
Console.WriteLine(result);
}
private List <Library> GetSortedLibraries(Library rootLibrary)
{
var traversed = new List <Library>();
var topologicalSort = new TopologicalSort <Library>();
var toTraverse = new Queue <Library>();
toTraverse.Enqueue(rootLibrary);
while (toTraverse.Count > 0)
{
Library predecessor = toTraverse.Dequeue();
if (traversed.Any(l => l.Equals(predecessor)) == false)
{
traversed.Add(predecessor);
}
topologicalSort.Node(predecessor);
foreach (Library successor in predecessor.Dependencies)
{
Library realSuccessor = traversed.Find(t => t.Equals(successor));
if (realSuccessor == null)
{
if (toTraverse.Any(l => l.Equals(successor)) == false)
{
toTraverse.Enqueue(successor);
}
realSuccessor = successor;
if (traversed.Any(l => l.Equals(realSuccessor)) == false)
{
traversed.Add(realSuccessor);
}
}
topologicalSort.Edge(predecessor, realSuccessor);
}
}
Queue <Library> sorted = topologicalSort.Sort();
List <Library> allLibraries = sorted.ToList();
return(allLibraries);
}
/// <inheritdoc />
public void Initialize()
{
void SortAspects()
{
const string sameKeyPrefix = "An item with the same key has already been added. Key: ";
try
{
var sortedAspects = TopologicalSort.Sort(_aspects, x => x.Dependencies, x => x.Id, ignoreCycles: false);
_aspects.Clear();
_aspects.AddRange(sortedAspects);
}
catch (ArgumentException e)
{
if (e.Message.StartsWith(sameKeyPrefix))
{
throw new Exception($"Aspect Id must be unique - {e.Message.Substring(sameKeyPrefix.Length)}");
}
throw;
}
catch (KeyNotFoundException e)
{
var parts = e.Message.Split('\'');
//TODO: USe RegEx
if (parts.Length == 3)
{
throw new Exception($"Missing dependency {parts[1]}");
}
throw;
}
}
_aspects.AddRange(_coreAspects);
SortAspects();
foreach (var aspect in _aspects)
{
aspect.Initialize();
}
}
