public BackToMenuFromDrawButton(AdjacencyList adjacencyList, List <VertexDraw> vertexDraws, List <EdgeDraw> edgeDraws, StartForm.DrawForm drawForm, AdjacencyListPanel adjacencyListPanel, WeightTable weightTable, List <List <CellBox> > matrix, List <List <CellAdjacencyList> > cells, string buttonText = "Menu") : base(buttonText) { ForeColor = Color.Black; this.BackColor = Color.Orange; Font = new System.Drawing.Font("Comic Sans MS", 11.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((System.Byte)(204))); FlatStyle = System.Windows.Forms.FlatStyle.Popup; Text = buttonText; Location = new System.Drawing.Point(300, 410); this.adjacencyList = adjacencyList; this.vertexDraws = vertexDraws; this.edgeDraws = edgeDraws; this.drawForm = drawForm; this.weightTable = weightTable; this.adjacencyListPanel = adjacencyListPanel; this.matrix = matrix; this.cells = cells; }
/// <summary> /// BFS made in tree format. Saving information of each node's parent /// </summary> /// <param name="dg"></param> /// <param name="startIndex"></param> /// <returns></returns> public static List <int?> BFS_tree(AdjacencyList dg, int startIndex) { int cont = 0; List <int?> visit = new List <int?>(); List <int?> parent = new List <int?>(); ///////// List <int> stack = new List <int>(); dg.Digraph.ForEach(_ => { visit.Add(null); parent.Add(null); }); visit[startIndex] = cont++; parent[startIndex] = startIndex; stack.Add(startIndex); while (stack.Any()) { int v = stack.First(); stack.RemoveAt(0); for (List <int> a = dg.Digraph[v]; a.Any(); a.RemoveAt(0)) { if (visit[a.First()] == null) { visit[a.First()] = cont++; parent[a.First()] = v; /////////// stack.Add(a.First()); } } } return(visit); }
public Graph ConnectNodes(LocationNode a, LocationNode b) { var containsA = AdjacencyList.Any(list => list.Contains(a)); var containsB = AdjacencyList.Any(list => list.Contains(b)); if (!containsA) { AddNode(a); } if (!containsB) { AddNode(b); } List <LocationNode>[] rootA = { new List <LocationNode>() }; List <LocationNode>[] rootB = { new List <LocationNode>() }; foreach (var list in AdjacencyList.Where(list => list[0] == a && rootA[0].Count == 0)) { rootA[0] = list; } foreach (var list in AdjacencyList.Where(list => list[0] == b && rootB[0].Count == 0)) { rootB[0] = list; } rootA[0].Add(b); rootB[0].Add(a); return(this); }
/// <summary> /// Dijkstra is an optimal algorithm for finding the shortest path in a digraph that has all positive ark values. /// </summary> /// <param name="dg"></param> /// <param name="startIndex"></param> /// <returns></returns> public static List <double> Dijkstra(AdjacencyList dg, int startIndex) { List <int?> parent = new List <int?>(); List <double> costs = new List <double>(); List <int> stack = new List <int>(); dg.Digraph.ForEach(_ => { parent.Add(null); costs.Add(double.MaxValue); }); costs[startIndex] = 0; parent[startIndex] = startIndex; stack.Add(startIndex); while (stack.Any()) { int node = stack.First(); stack.Remove(node); foreach (var ark in dg.WeightedDigraph.OrderBy(x => x.value).Where(x => x.initialNode == node)) { if (costs[ark.finalNode] == double.MaxValue) { parent[ark.finalNode] = ark.initialNode; costs[ark.finalNode] = costs[ark.initialNode] + ark.value; stack.Add(ark.finalNode); } else if (costs[ark.finalNode] > costs[ark.initialNode] + ark.value) { parent[ark.finalNode] = ark.initialNode; costs[ark.finalNode] = costs[ark.initialNode] + ark.value; } } } return(costs); }
/// <summary> /// Minimal path finder algorithm when not all arks have positive values. /// </summary> /// <param name="dg"></param> /// <param name="startIndex"></param> /// <returns></returns> public static List <double> Bellman_Ford(AdjacencyList dg, int startIndex) { List <int?> parent = new List <int?>(); List <double> dist = new List <double>(); dg.Digraph.ForEach(x => { parent.Add(null); dist.Add(double.MaxValue); }); parent[startIndex] = startIndex; dist[startIndex] = 0; for (int i = 0; i < dg.Digraph.Count; i++) { foreach (var ark in dg.WeightedDigraph) { RELAX(ark, ref parent, ref dist); } } if (verifyCicloNegativo(dg, ref dist)) { return(dist); } else { return(new List <double>()); } }
public Graph ConvertToGraph(AdjacencyList adjacencyList) { Graph graph = new Graph(); Vertex vertex = new Vertex(); graph.Vertexs = new List <Vertex>(adjacencyList.adjacencyList.Count); for (int i = 0; i < adjacencyList.adjacencyList.Count; i++) { vertex.Nodes = new List <Node>(adjacencyList.adjacencyList[i].Count); for (int j = 0; j < adjacencyList.adjacencyList[i].Count; j++) { vertex.Nodes.Add(new Node() { Weight = adjacencyList.adjacencyList[i][j].Weight, Connectable = adjacencyList.adjacencyList[i][j].Connectable }); } graph.Vertexs.Add(new Vertex() { Nodes = vertex.Nodes, Id = i }); } return(graph); }
/// <summary> /// Digraph Distance calculation. The metrics in this method is quantity of nodes or 'steps'. Not a valued distance /// </summary> /// <param name="dg"></param> /// <param name="startIndex"></param> /// <returns></returns> public static List <int?>[] DIGRAPHdist(AdjacencyList dg, int startIndex) { List <int?> dist = new List <int?>(); List <int?> parent = new List <int?>(); List <int> stack = new List <int>(); dg.Digraph.ForEach(_ => { dist.Add(null); parent.Add(null); }); dist[startIndex] = 0; parent[startIndex] = startIndex; stack.Add(startIndex); while (stack.Any()) { List <int> a; int v = stack.First(); stack.RemoveAt(0); for (a = dg.Digraph.First(); a.Any(); a.RemoveAt(0)) { if (dist[a.First()] == null) { dist[a.First()] = dist[v] + 1; parent[a.First()] = v; stack.Add(a.First()); } } } return(new List <int?>[] { dist, parent }); }
static LinkedList <int> SearchConnectedComponent(AdjacencyList list, int source, ref bool[] checkpoint) { var q = new Queue <int>(); q.Enqueue(source); checkpoint[source] = true; var tmp = new LinkedList <int>(); tmp.AddLast(source); while (q.Count != 0) { source = q.Dequeue(); foreach (var item in list.List[source]) { if (checkpoint[item]) { continue; } checkpoint[item] = true; tmp.AddLast(item); q.Enqueue(item); } } return(tmp); }
public DeleteAllButton(int width, int height, AdjacencyList adjacencyList, List <VertexDraw> vertexDraws, List <EdgeDraw> edgeDraws, StartForm.DrawForm drawForm, AdjacencyListPanel adjacencyListPanel, WeightTable weightTable, List <List <CellBox> > matrix, List <List <CellAdjacencyList> > cells) { Size = new System.Drawing.Size(width, height); Dock = DockStyle.Top; Text = "Delete all"; Click += new EventHandler(ButtonClick); this.adjacencyList = adjacencyList; this.vertexDraws = vertexDraws; this.edgeDraws = edgeDraws; this.drawForm = drawForm; this.weightTable = weightTable; this.adjacencyListPanel = adjacencyListPanel; this.matrix = matrix; this.cells = cells; }
/// <summary> /// Check bridges /// </summary> /// <param name="list"></param> static void Process1(AdjacencyList list) { int n = FindConnectedComponent(list).Count(); for (int i = 0; i < list.List.Length; i++) { foreach (var item in list.List[i]) { var tmp = DeepCopy(list); // 1. Remove the edge tmp.List[i].Remove(item); tmp.List[item].Remove(i); // 2. Counting connected components int m = FindConnectedComponent(tmp).Count(); // 3. Comparing and printing result if (m > n) { WriteLine($"[{i}, {item}] is a brigde"); } else { WriteLine($"[{i}, {item}] is not a brigde"); } } } WriteLine(); }
/// <summary> /// Check articulation points /// </summary> /// <param name="list"></param> static void Process2(AdjacencyList list) { int n = FindConnectedComponent(list).Count(); for (int i = 0; i < list.List.Length; i++) { var tmp = DeepCopy(list); // 1. Remove the vertex tmp.List[i].Clear(); // 2. Remove the edges that connect to the vertex for (int j = 0; j < tmp.Vertices; j++) { tmp.List[j].Remove(i); } // 3. Decrease 1: not counting the connected-component of removed-vertex int m = FindConnectedComponent(tmp).Count() - 1; // Compare and print result if (m > n) { WriteLine($"Vertex[{i}] is a articulation point"); } else { WriteLine($"Vertex[{i}] is not a articulation point"); } } WriteLine(); }
void CallGraph() { graph = DungeonMapData.data[location]; //eventMap = DungeonMapData.lectureEvents; //eventCatcher = gameObject.transform.parent.parent.GetComponent<Dungeon>(); graph.unityView = this; foreach (Transform child in gameObject.transform) { AdjacencyList edges = graph.edges[child.gameObject.GetComponent <RoomNode>().ID]; string fromKey = edges.self; Vector3 fromPos = gameObject.transform.Find(fromKey).position; foreach (string toKey in edges.destinations) { Vector3 toPos = gameObject.transform.Find(toKey).position; GameObject line = Instantiate(edgeLine, edgeSpace); line.transform.position = new Vector3((fromPos.x + toPos.x) / 2, (fromPos.y + toPos.y) / 2, 0); line.transform.localScale = new Vector3(1, (float)System.Math.Sqrt(System.Math.Pow(fromPos.x - toPos.x, 2) + System.Math.Pow(fromPos.y - toPos.y, 2) + System.Math.Pow(fromPos.z - toPos.z, 2)) / 150, 1); //Debug.Log(line.transform.localScale.ToString()); if (toPos.x - fromPos.x != 0 && toPos.y - fromPos.y != 0) { line.transform.Rotate(new Vector3(0, 0, (float)(-1 * (90 - System.Math.Atan((toPos.y - fromPos.y) / (toPos.x - fromPos.x)) * 180 / 3.14)))); //Debug.Log(System.Math.Acos((toPos.x - fromPos.x) / (toPos.y - fromPos.y)).ToString()); } else if (toPos.y - fromPos.y == 0) { line.transform.Rotate(new Vector3(0, 0, 90)); } //line.transform.SetAsFirstSibling(); } } }
public void ShortestPathSearcher_Integration_DefaultAggregativeWeight() { string vertexA = "A", vertexB = "B", vertexC = "C", vertexD = "D"; // Graph A-B, A-C, B-D, B-A AdjacencyList <string, int> graph = new AdjacencyList <string, int>(); graph.AddVertex(vertexA); graph.AddVertex(vertexB); graph.AddVertex(vertexC); graph.AddVertex(vertexD); graph.AddEdge(vertexA, vertexB, 10); graph.AddEdge(vertexB, vertexA, 5); graph.AddEdge(vertexA, vertexC, 20); graph.AddEdge(vertexB, vertexD, 10); ShortestPathSearcher <string, int> searcher = new ShortestPathSearcher <string, int>(graph, vertexA, vertexD, (i) => i); IEnumerable <EdgeDescriptor <string, int> > path = searcher.FindShortestPath(); Assert.IsNotNull(path); Assert.AreEqual(2, path.Count()); EdgeDescriptor <string, int> firstDesc = path.First(); Assert.AreEqual("B", firstDesc.Vertex1); Assert.AreEqual("A", firstDesc.Vertex2); Assert.AreEqual(5, firstDesc.Edge); EdgeDescriptor <string, int> lastDesc = path.Last(); Assert.AreEqual("B", lastDesc.Vertex1); Assert.AreEqual("D", lastDesc.Vertex2); Assert.AreEqual(10, lastDesc.Edge); }
public void ShortestPathSearcher_Integration_CumulativeWeight() { string vertexA = "A", vertexB = "B", vertexC = "C"; // Graph A-B=2, A-C=3, B-C=4 AdjacencyList <string, int> graph = new AdjacencyList <string, int>(); graph.AddVertex(vertexA); graph.AddVertex(vertexB); graph.AddVertex(vertexC); graph.AddEdge(vertexA, vertexB, 2); graph.AddEdge(vertexA, vertexC, 3); graph.AddEdge(vertexB, vertexC, 4); ShortestPathSearcher <string, int> searcher = new ShortestPathSearcher <string, int>(graph, vertexB, vertexC, (i) => i) { PathWeightCalculation = PathWeightCalculationType.Cumulative }; IEnumerable <EdgeDescriptor <string, int> > path = searcher.FindShortestPath(); Assert.IsNotNull(path); Assert.AreEqual(2, path.Count()); EdgeDescriptor <string, int> edge1 = path.First(); Assert.AreEqual("A", edge1.Vertex1); Assert.AreEqual("B", edge1.Vertex2); Assert.AreEqual(2, edge1.Edge); EdgeDescriptor <string, int> edge2 = path.Last(); Assert.AreEqual("A", edge2.Vertex1); Assert.AreEqual("C", edge2.Vertex2); Assert.AreEqual(3, edge2.Edge); }
/// <summary> /// Computes and assigns a dimensionfactor to all nodes which appear in an adjacencylist /// The dimensionfactor is a float value between 0 and 1 and states /// the indegree/outdegree ratio a node has in its dimensionlayer. This value can be used /// by frontend applications to easily position the objects /// </summary> /// <remarks>A visual example is given in the related testproject</remarks> internal static void ComputeDimensionFactors(AdjacencyList adjacencyList) { foreach (var group in adjacencyList.Groups) { foreach (var edge in group.Value.Edges) { Queue <Node> sourceStack = new Queue <Node>(); Queue <Node> targetStack = new Queue <Node>(); GetUpperTreePart(sourceStack, edge.Value.Source); GetUpperTreePart(targetStack, edge.Value.Target); while (sourceStack.Count > targetStack.Count) { sourceStack.Dequeue(); } while (targetStack.Count > sourceStack.Count) { targetStack.Dequeue(); } while (true) { Node currentSource = sourceStack.Dequeue(); Node currentTarget = targetStack.Dequeue(); if (sourceStack.Count == 0 || sourceStack.Peek().Id.Equals(targetStack.Peek().Id)) { currentSource.IsSource(); currentTarget.IsTarget(); break; } } } } }
public void AdjacencyList_Filter_SelectesPartOfVertices() { int vertex1 = 10; int vertex2 = 20; int vertex3 = 30; int vertex4 = 40; string edge1 = "20-30"; string edge2 = "30-40"; AdjacencyList <int, string> adjacencyList = new AdjacencyList <int, string>(); adjacencyList.AddVertex(vertex1); adjacencyList.AddVertex(vertex2); adjacencyList.AddVertex(vertex3); adjacencyList.AddVertex(vertex4); adjacencyList.AddEdge(vertex2, vertex3, edge1); adjacencyList.AddEdge(vertex3, vertex4, edge2); IGraph <int, string> filtered = adjacencyList.Filter((v1, v2, ed) => v1 == 20); Assert.Equal(2, filtered.NumVertices); Assert.True(filtered.HasVertex(vertex2)); Assert.True(filtered.HasVertex(vertex3)); Assert.Equal(edge1, filtered.FindEdge(vertex2, vertex3)); }
public void GetEdgesFrom_ShouldReturnAllEdgesStartingFromStartVertex() { var startVertex = 'C'; var expected = new List <DirectedEdge> { new DirectedEdge(startVertex, 'D', 6) , new DirectedEdge(startVertex, 'E', 8) , new DirectedEdge(startVertex, 'A', 1) }; var target = new AdjacencyList(); foreach (var edge in expected) { target.AddDirectedEdge(edge); } var actual = target.GetEdgesFrom(startVertex); for (var i = 0; i < actual.Count; i++) { Assert.That(actual[i].StartVertex, Is.EqualTo(expected[i].StartVertex)); Assert.That(actual[i].EndVertex, Is.EqualTo(expected[i].EndVertex)); Assert.That(actual[i].Weight, Is.EqualTo(expected[i].Weight)); } }
public void Load_Empty_List() { int expected = 0; AdjacencyList list = new AdjacencyList("empty.txt"); Assert.AreEqual(expected, list.Count); }
public void Load_Trash_List() { int expected = 0; AdjacencyList list = new AdjacencyList("trash.txt"); Assert.Inconclusive(); }
public void Load_2x2_List() { int expected = 4; AdjacencyList list = new AdjacencyList("2x2onecolor.txt"); Assert.AreEqual(expected, list.Count); }
public void Load_3x3_List() { int expected = 9; AdjacencyList list = new AdjacencyList("3x3.txt"); Assert.AreEqual(expected, list.Count); }
public void AdjacencyList_RemoveVertex_RemovesVerticesWithEdges() { int vertex1 = 10; int vertex2 = 20; int vertex3 = 30; int vertex4 = 40; string edge1 = "20-30"; string edge2 = "30-40"; AdjacencyList <int, string> adjacencyList = new AdjacencyList <int, string>(); adjacencyList.AddVertex(vertex1); adjacencyList.AddVertex(vertex2); adjacencyList.AddVertex(vertex3); adjacencyList.AddVertex(vertex4); adjacencyList.AddEdge(vertex2, vertex3, edge1); adjacencyList.AddEdge(vertex3, vertex4, edge2); Assert.Equal(4, adjacencyList.NumVertices); Assert.Equal(edge1, adjacencyList.FindEdge(vertex2, vertex3)); Assert.Equal(edge2, adjacencyList.FindEdge(vertex3, vertex4)); adjacencyList.RemoveVertex(vertex2); Assert.Equal(3, adjacencyList.NumVertices); Assert.Equal(edge2, adjacencyList.FindEdge(vertex3, vertex4)); }
static bool CheckBipartite(AdjacencyList list, int source, ref bool[] checkpoint, ref int[] flag) { foreach (var item in list.List[source]) { if (!checkpoint[item]) { checkpoint[item] = true; if (flag[source] == 0) { flag[item] = 1; } else { flag[item] = 0; } if (!CheckBipartite(list, item, ref checkpoint, ref flag)) { return(false); } } // If the vertex item is traversed else if (flag[source] == flag[item]) { return(false); } } // In the end, if there is nothing happened, return true return(true); }
private void setList(List <List <int> > data) { AdjacencyList al = new AdjacencyList(); data = al.ParseFile <int>(globals.Filepath); graph.setData(data); vertices_count = graph.getData <int>().Count; graph.VerticesAmount = vertices_count; //number of vertices to be colored color_array = new int[vertices_count]; //number of vertices which each of vertex represented by the list index and the value is the component class number connected_comps = new int[vertices_count]; Dispatcher.Invoke(new Action(() => { if (algorithms.isBipartite <int>(graph, vertices_count, color_array, GraphTypes.Sparse, connected_comps)) { setViewBI(); } else { setViewNotBi(); } MainViewModel.getInstance().ProgressText = "Adjacency list loaded successfully!"; MainViewModel.getInstance().ProgressVal = 50; })); }
public void ConvertToSimpleGrapgTest_ThreeVertexList_GraphThreeVertex() { List <Vertex> vertices = new List <Vertex> { new Vertex { Id = 1, Nodes = new List <Node> { new Node { Connectable = 0, Weight = 12 }, new Node { Connectable = 2, Weight = 10 } } }, new Vertex { Id = 0, Nodes = new List <Node> { new Node { Connectable = 2, Weight = 5 } } }, new Vertex { Id = 2, Nodes = new List <Node>() } }; AdjacencyList adjacencyList = new AdjacencyList(vertices); List <List <int> > graph = converter.ConvertToSimpleGraph(adjacencyList); Assert.IsTrue(graph[0].SequenceEqual(new List <int> { 2 }) && graph[1].SequenceEqual(new List <int> { 0, 2 }) && graph[2].SequenceEqual(new List <int>())); }
public void VertexFind(NewEdgeDefinition vertexClick, MouseEventArgs e, List <VertexDraw> vertexDraws, List <EdgeDraw> edgeDraws, ref int startVertexId, ref int endVertexId, ref AdjacencyList adjacencyList, AdjacencyListPanel adListPanel, MatrixWeightPanel matrixWeightPanel) { vertexClick.VertexRemember(ref startVertexId, ref endVertexId , e.X - (int)VertexParameters.Radius, e.Y - (int)VertexParameters.Radius , vertexDraws); if ((startVertexId != -1) && (endVertexId != -1) && (startVertexId != endVertexId) && (!IsDuplicate(edgeDraws, startVertexId, endVertexId))) { EdgeDraw edgeDraw = new EdgeDraw(BrushColor.Black, 0, startVertexId, endVertexId); edgeDraws.Add(edgeDraw); adjacencyList.AddNode(startVertexId, endVertexId, 1); adListPanel.UpdateNodesPanel(startVertexId, endVertexId); matrixWeightPanel.UpdateNodes(startVertexId, endVertexId); startVertexId = -1; endVertexId = -1; } else if (IsDuplicate(edgeDraws, startVertexId, endVertexId)) { startVertexId = -1; endVertexId = -1; } }
public static void Solve() { var n = I; var m = I; var l = new int[m]; var r = new int[m]; var d = new long[m]; var gr = new AdjacencyList <long>(n); Repeat(m, i => { l[i] = I - 1; r[i] = I - 1; d[i] = L; gr.Add(l[i], r[i], d[i]); gr.Add(r[i], l[i], -d[i]); }); var x = new long[n]; foreach (var edge in gr.DepthFirstSearch()) { x[edge.Target] = x[edge.Source] + edge.Cost; } Repeat(m, j => { if (x[r[j]] - x[l[j]] != d[j]) { Answer(No); } }); Answer(Yes); }
/// <summary> /// テスト用メインメソッド /// </summary> public static void Main(string[] args) { // AdjacencyList graph = ReadGraph(Common.INSTANCE_PATH + @"undirected_sample.grp"); AdjacencyList graph = ReadGraph(Common.INSTANCE_PATH + @"directed_sample.grp"); Console.WriteLine("n : " + graph.NodeNum); Console.WriteLine("m : " + graph.EdgeNum); foreach (int[] edge in graph.EdgeList) { Console.WriteLine(edge[0] + "," + edge[1]); } Console.WriteLine("\n===== in ====="); for (int i = 0; i < graph.NodeNum; i++) { Console.WriteLine("===" + i + "==="); for (LinkNode node = graph.GetInLinkedEdgeList(i).head; node != null; node = node.next) { Console.WriteLine(node.data); } } Console.WriteLine("\n===== out ====="); for (int i = 0; i < graph.NodeNum; i++) { Console.WriteLine("===" + i + "==="); for (LinkNode node = graph.GetOutLinkedEdgeList(i).head; node != null; node = node.next) { Console.WriteLine(node.data); } } }
public DFSTest() { AdjacencyList <int> adjacencyList = new AdjacencyList <int>(); ForDFSNode <int> firstHead = new ForDFSNode <int> { Data = 1 }; ForDFSNode <int> secondHead = new ForDFSNode <int> { Data = 2 }; ForDFSNode <int> thirdHead = new ForDFSNode <int> { Data = 3 }; ForDFSNode <int> forthHead = new ForDFSNode <int> { Data = 4 }; adjacencyList.Nodes.AddRange(new List <ForDFSNode <int> > { firstHead, secondHead, thirdHead, forthHead }); adjacencyList.NeighborsList.Add(firstHead, new List <Node <int> > { secondHead, forthHead }); adjacencyList.NeighborsList.Add(secondHead, new List <Node <int> > { firstHead, thirdHead, forthHead }); adjacencyList.NeighborsList.Add(thirdHead, new List <Node <int> > { secondHead, forthHead }); adjacencyList.NeighborsList.Add(forthHead, new List <Node <int> > { firstHead, secondHead, thirdHead }); _dfs = new DFS <int>(adjacencyList); }
static void Main(string[] args) { AdjacencyList lst = new AdjacencyList(7); lst.AddUndirectedArk(0, 2, 5); lst.AddUndirectedArk(0, 3, 8); lst.AddUndirectedArk(2, 3, 10); lst.AddUndirectedArk(2, 1, 16); lst.AddUndirectedArk(2, 4, 3); lst.AddUndirectedArk(3, 4, 2); lst.AddUndirectedArk(3, 5, 18); lst.AddUndirectedArk(4, 1, 30); lst.AddUndirectedArk(4, 5, 12); lst.AddUndirectedArk(4, 6, 14); lst.AddUndirectedArk(1, 6, 26); lst.AddUndirectedArk(5, 6, 4); var pre = Common.Helper.Kruskal(lst); lst.Show(); Console.WriteLine("Pre vector: "); for (int i = 0; i < pre.Count; i++) { Console.Write($"[{i}] "); } Console.WriteLine(); pre.ForEach(x => { Console.Write($" {x} "); }); System.Console.ReadKey(); }
public static bool JudgeEulerian(AdjacencyList graph) { // 連結性判定 int[] cc = GraphScanning.CalcDepth(graph, 0); if (cc.Length != graph.NodeNum) { return(false); } // 有向グラフ if (graph.IsDirected) { // 全てのノードにおいて、入次数と出次数が同じならオイラーグラフ for (int i = 0; i < graph.NodeNum; i++) { // Inリストのノード数が入次数 LinkList list = graph.GetInLinkedEdgeList(i); int in_count = 0; for (LinkNode node = list.head; node != null; node = node.next) { in_count++; } // Outリストのノード数が出次数 list = graph.GetOutLinkedEdgeList(i); int out_count = 0; for (LinkNode node = list.head; node != null; node = node.next) { out_count++; } // 入次数と出次数が異なるなら終了 if (in_count != out_count) { return(false); } } // 無向グラフの場合 } else { // 全てのノードの次数が偶数ならオイラーグラフ for (int i = 0; i < graph.NodeNum; i++) { // リストのノード数が次数 LinkList list = graph.GetInLinkedEdgeList(i); int count = 0; for (LinkNode node = list.head; node != null; node = node.next) { count++; } // 次数が奇数なら終了 if (count % 2 != 0) { return(false); } } } return(true); }
public void TestGetEdgesEmptyGraph() { AdjacencyList <int> graph = new AdjacencyList <int>(); bool thrown = false; for (int i = 0; i < 100; i++) { try { graph.GetEdges(i); } catch (KeyNotFoundException) { thrown = true; } if (!thrown) { Assert.Fail("Exception not thrown"); } } Assert.Pass(); }
/// <summary> /// Clones a Node by pointing to the same memebers /// </summary> /// <param name="node"></param> /// public Node(INode <KEY> node) { if (node == null) { return; } _key = node.Key; _data = node.Data; _properties = node.Properties; Node <KEY> nodeT = node as Node <KEY>; if (nodeT != null) { _edges = nodeT._edges; _adjacencyList = nodeT._adjacencyList; } else { foreach (INode <KEY> n in node.AdjacentNodes) { AdjacencyList.Add(n); } foreach (IEdge <KEY> edge in node.EdgeSet) { Edges.Add(new KeyValuePair <EdgeKey <KEY>, IEdge <KEY> >(new EdgeKey <KEY>(edge.SourceNode.Key, edge.TargetNode.Key), edge)); } } }
/// <summary> /// Designed to compute the Strongly Connected Components /// </summary> /// <param name="graph"></param> /// <param name="startNode"></param> /// <param name="nodeOrder"></param> public DepthFirstSearch(AdjacencyList <TNode, TWeight> graph, List <TNode> nodeOrder) { if (!graph.HasTheNode(startNode)) { throw new NotImplementedException(); } this.InitializeMembers(graph, nodeOrder[0]); foreach (TNode node in graph) { this.searchResult.AddNode(node); labels.Add(node, new FastDepthFirstSearchNode <TNode>(node, null, null)); } int time = 0; foreach (TNode node in nodeOrder) { if (labels[node].IsWhite()) { Visit(node, ref time); } } }
public void AdjacencyList_Should_Be_Equal_To_Colored_Vertices() { AdjacencyList list = new AdjacencyList("2x2onecolor.txt"); var colorsLine = File.ReadLines("2x2onecolor.txt").First(); var colors = colorsLine.Split(new [] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(short.Parse); Assert.AreEqual(list.Count(), colors.Count()); }
public void DontColorMyMatrix() { AdjacencyList list = new AdjacencyList("2x2onecolor.txt"); var colorsLine = File.ReadLines("2x2onecolor.txt").First(); var colors = colorsLine.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(short.Parse); IGraphTraversal traversal = new MatrixTraversal(list, colors.ToArray()); IColorator colorator = new MatrixColorator(traversal); colorator.Color(); }
public Node(string key, object data, AdjacencyList neighbors) { Key = key; Data = data; if (neighbors == null) { Neighbors = new AdjacencyList(); } else { Neighbors = neighbors; } }
public Node(string key, object data, double latitude, double longitude, AdjacencyList neighbors) { Key = key; Data = data; Latitude = latitude; Longitude = longitude; if (neighbors == null) { Neighbors = new AdjacencyList(); } else { Neighbors = neighbors; } }
public void Initialize(AdjacencyList list, short[] clr) { if (list == null || clr == null) { throw new ArgumentException("Input parameters shouldn't be null"); } adjacencyList = list; // markedVertices = new bool[adjacencyList.Count + 1]; verticesColoring = new short[clr.Count() + 1]; // some extra reindexing operation just for comfort for (int i = 1; i < verticesColoring.Count(); i++) { verticesColoring[i] = clr[i - 1]; } }
private static void BellmanFord() { var directedGraph = new AdjacencyList(5); directedGraph.Add(1, 2, 1); directedGraph.Add(1, 1, 4); // bellman-ford accepts cycles, And negative weights too. // directedGraph.Add(2, 3, -5); directedGraph.Add(3, 4, -2); directedGraph.Add(4, 0, 2); directedGraph.Add(4, 3, -2); var bF = new BellmanFord(); bF.Compute(directedGraph, 1); for (int i = 0; i < bF.Shortest.Length; i++) Console.WriteLine("\t {0} + -> Weights : [{1}]", i, bF.Shortest[i]); Console.WriteLine("\nPredessors: "); for (int i = 0; i < bF.Predecessors.Length; i++) { var pred = bF.Predecessors[i]; Console.WriteLine("pred[{0}] : {1}", i, pred != null ? pred.ToString() : "NULL"); } Console.WriteLine("Negative Cycle :"); bF.FindNegativeWeightCycle(directedGraph).ForEach(i => Console.Write(i + " -> ")); Console.WriteLine(); }
public static void Dag() { var dag = new AdjacencyMatrix(5); dag.Add(0, 2); dag.Add(1, 4); dag.Add(6, 3); // Bad Input .. nothing // dag.Add(3, 4); Console.WriteLine("\n " + dag); Console.WriteLine("Topological Sort result :"); var l = DagAlgorithms.TopologicalSort(dag); l.ForEach((i) => Console.WriteLine(i)); var dag2 = new AdjacencyList(5); dag2.Add(0, 2, 1); dag2.Add(1, 4, 10); dag2.Add(2, 3, 5); dag2.Add(3, 1, 2); dag2.Add(3, 4, 1); Console.WriteLine(dag2); Console.WriteLine("\t Vertices: " + dag2.N + "\n\t Edges: " + dag2.M); Console.WriteLine("\nTopological Sort result :"); var l1 = DagAlgorithms.TopologicalSort(dag2); l1.ForEach((i) => Console.WriteLine(i)); // test removing an edge .. // dag2.Remove(1, 4); Console.WriteLine(dag2); Console.WriteLine("\nTopological Sort result :"); var l2 = DagAlgorithms.TopologicalSort(dag2); l2.ForEach((i) => Console.WriteLine(i)); Console.WriteLine("Shortest Path: "); var dagAlgo = new DagAlgorithms(); dagAlgo.ShortestPath(dag2, 0); for (int i = 0; i < dagAlgo.Shortest.Length; i++) Console.WriteLine("\t {0} + -> Weights : [{1}]", i, dagAlgo.Shortest[i]); Console.WriteLine("\nPredessors: "); for (int i = 0; i < dagAlgo.Predecessors.Length; i++) { var pred = dagAlgo.Predecessors[i]; Console.WriteLine("pred[{0}] : {1}", i, pred != null ? pred.ToString() : "NULL"); } var dagTime = new AdjacencyList(5); // Or AdjacencyMatrix(5) // dagTime.Add(1, 2, 2.5); dagTime.Add(1, 3, 5); dagTime.Add(3, 4, 3.25); //dagTime.Add(4, 0, null); // if e.g.: Unreachable in P time // dagTime.Add(4, 0, 10.5); Console.WriteLine(dagTime); Console.WriteLine("\nShortest Path: "); var dagAlgo2 = new DagAlgorithms(); dagAlgo2.ShortestPath(dagTime, 1); for (int i = 0; i < dagAlgo2.Shortest.Length; i++) Console.WriteLine("\t {0} + -> Weights : [{1}]", i, dagAlgo2.Shortest[i]); Console.WriteLine("\nPredessors: "); for (int i = 0; i < dagAlgo2.Predecessors.Length; i++) { var pred = dagAlgo2.Predecessors[i]; Console.WriteLine("pred[{0}] : {1}", i, pred != null ? pred.ToString() : "NULL"); } }
private static void Dikstra() { var directedGraph = new AdjacencyList(5); directedGraph.Add(1, 2, 1); directedGraph.Add(1, 1, 4); // Dijkstra accepts cycles, But not negative weights // directedGraph.Add(2, 3, 5); directedGraph.Add(3, 4, 10); directedGraph.Add(4, 0, 2); var dijskra = new Dijkstra(); dijskra.Compute(directedGraph, 1); for (int i = 0; i < dijskra.Shortest.Length; i++) Console.WriteLine("\t {0} + -> Weights : [{1}]", i, dijskra.Shortest[i]); Console.WriteLine("\nPredessors: "); for (int i = 0; i < dijskra.Predecessors.Length; i++) { var pred = dijskra.Predecessors[i]; Console.WriteLine("pred[{0}] : {1}", i, pred != null ? pred.ToString() : "NULL"); } }
public MatrixTraversal(AdjacencyList list, short[] clr) { Initialize(list, clr); }
public RoadNetwork() { nodesIds = new List<long>(); adjacentArcs = new AdjacencyList<Node>(); mapNodeId = new Dictionary<long, Node>(); }