public void IsBipartite_ForBiggerGraphs() { // This graph is some bipartite mess. Odds and evens go in their own set, edges between them haphazardly. var graph = SimpleGraph.CreateFromOneBasedEdges(22, new[, ] { { 2, 3 }, { 2, 9 }, { 2, 11 }, { 2, 15 }, { 4, 1 }, { 4, 7 }, { 4, 11 }, { 4, 17 }, { 6, 1 }, { 6, 11 }, { 6, 7 }, { 6, 15 }, { 8, 1 }, { 8, 15 }, { 8, 13 }, { 8, 17 }, { 10, 1 }, { 10, 3 }, { 10, 13 }, { 10, 15 }, { 14, 1 }, { 16, 3 }, { 16, 7 }, { 16, 17 }, { 16, 1 }, { 16, 3 }, { 16, 7 }, { 16, 17 }, { 16, 9 }, { 16, 11 }, { 16, 5 }, { 16, 19 }, { 18, 9 }, { 18, 11 }, { 18, 5 }, { 18, 19 }, { 20, 21 } }); Assert.IsTrue(graph.IsBipartite()); // This graph is like above, except I threw in an edge between an even pair of vertices. graph = SimpleGraph.CreateFromOneBasedEdges(22, new[, ] { { 2, 3 }, { 2, 9 }, { 2, 11 }, { 2, 15 }, { 4, 1 }, { 4, 7 }, { 4, 11 }, { 4, 17 }, { 6, 1 }, { 6, 11 }, { 6, 7 }, { 6, 15 }, { 8, 1 }, { 8, 15 }, { 8, 13 }, { 8, 17 }, { 10, 1 }, { 10, 3 }, { 10, 13 }, { 10, 15 }, { 14, 1 }, { 16, 3 }, { 16, 7 }, { 16, 17 }, { 16, 1 }, { 16, 3 }, { 16, 7 }, { 16, 17 }, { 16, 9 }, { 16, 11 }, { 16, 5 }, { 16, 19 }, { 18, 9 }, { 18, 11 }, { 18, 5 }, { 18, 19 }, { 20, 21 }, { 10, 16 } }); Assert.IsFalse(graph.IsBipartite()); }
//Iterative depth-first search that returns the node with the target data. public static GraphNode <T> DFS <T>(this SimpleGraph <T> graph, T target) { if (graph == null || graph.Nodes.Count == 0) { return(null); } var visited = new HashSet <GraphNode <T> >(); var stack = new DataStructures.Stack <GraphNode <T> >(); stack.Push(graph.Root); while (!stack.IsEmpty) { GraphNode <T> curr = stack.Pop(); if (visited.Contains(curr)) { continue; } if (curr.Data.Equals(target)) { return(curr); } visited.Add(curr); foreach (GraphNode <T> neighbor in curr.Neighbors) { stack.Push(neighbor); } } return(null); }
public void FindFurthestVertex3() { // This graph is a line broken in two. var graph = SimpleGraph.CreateFromZeroBasedEdges(6, new[, ] { { 0, 1 }, { 1, 2 }, { 3, 4 }, { 4, 5 } }); Assert.AreEqual(2, graph.FindFurthestVertex(0).Item1.ID); Assert.AreEqual(2, graph.FindFurthestVertex(0).Item2); Assert.IsTrue(graph.FindFurthestVertex(1).Item1.ID == 2 || graph.FindFurthestVertex(1).Item1.ID == 0); Assert.AreEqual(1, graph.FindFurthestVertex(1).Item2); Assert.AreEqual(0, graph.FindFurthestVertex(2).Item1.ID); Assert.AreEqual(2, graph.FindFurthestVertex(2).Item2); Assert.AreEqual(5, graph.FindFurthestVertex(3).Item1.ID); Assert.AreEqual(2, graph.FindFurthestVertex(3).Item2); Assert.IsTrue(graph.FindFurthestVertex(4).Item1.ID == 3 || graph.FindFurthestVertex(4).Item1.ID == 5); Assert.AreEqual(1, graph.FindFurthestVertex(4).Item2); Assert.AreEqual(3, graph.FindFurthestVertex(5).Item1.ID); Assert.AreEqual(2, graph.FindFurthestVertex(5).Item2); }
static void Init() { // Get existing open window or if none, make a new one: SimpleGraph window = (SimpleGraph)EditorWindow.GetWindow(typeof(SimpleGraph)); window.Show(); }
protected override void AssertPipGraphContent(PipGraph pipGraph, SimpleGraph file2file, StringTable stringTable) { AssertPipGraphCounts(pipGraph, new Dictionary <PipType, int> { [PipType.Process] = file2file.NodeCount, [PipType.SealDirectory] = file2file.NodeCount, }); var processPips = pipGraph.RetrievePipsOfType(PipType.Process).ToList(); // assert edges exist Assert.All( file2file.Edges, edge => { var errPrefix = $"Edge ({edge.Src})->({edge.Dest}) not found: "; var srcPip = FindPipByTag(processPips, GetProcTag(edge.Src), stringTable); var destPip = FindPipByTag(processPips, GetProcTag(edge.Dest), stringTable); var producedSealDirectoryPips = pipGraph.RetrievePipImmediateDependents(destPip).Where(pip => pip.PipType == PipType.SealDirectory).ToList(); XAssert.AreEqual(1, producedSealDirectoryPips.Count, $"{errPrefix} expected to find exactly one SealDirectory dependency of Process Pip {destPip}"); var producedSealDirectoryPip = producedSealDirectoryPips.First(); var deps = pipGraph.RetrievePipImmediateDependents(producedSealDirectoryPip); if (!deps.Contains(srcPip)) { XAssert.Fail($"{errPrefix} expected edges between {srcPip} <-- {producedSealDirectoryPip} <-- {destPip}; dependencies of Pip {producedSealDirectoryPip} are: {XAssert.SetToString(deps)}"); } }); }
public void FindFurthestVertex2() { // This graph is a line. var graph = SimpleGraph.CreateFromZeroBasedEdges(6, new[, ] { { 0, 1 }, { 1, 2 }, { 2, 3 }, { 3, 4 }, { 4, 5 } }); Assert.AreEqual(5, graph.FindFurthestVertex(0).Item1.ID); Assert.AreEqual(5, graph.FindFurthestVertex(0).Item2); Assert.AreEqual(5, graph.FindFurthestVertex(1).Item1.ID); Assert.AreEqual(4, graph.FindFurthestVertex(1).Item2); Assert.AreEqual(5, graph.FindFurthestVertex(2).Item1.ID); Assert.AreEqual(3, graph.FindFurthestVertex(2).Item2); Assert.AreEqual(0, graph.FindFurthestVertex(3).Item1.ID); Assert.AreEqual(3, graph.FindFurthestVertex(3).Item2); Assert.AreEqual(0, graph.FindFurthestVertex(4).Item1.ID); Assert.AreEqual(4, graph.FindFurthestVertex(4).Item2); Assert.AreEqual(0, graph.FindFurthestVertex(5).Item1.ID); Assert.AreEqual(5, graph.FindFurthestVertex(5).Item2); }
private IEnumerator LinkSpheres() { Debug.Log("Linking Spheres"); SphereGraph = new SimpleGraph(Spheres.Count, 2 * Portals.Count); // How much is our offset for the second arc int BidirectionOffset = Portals.Count; // Every portal is a connection between spheres, so lets do that foreach (CameraGraphPortalNode portal in Portals) { // Indices for the sphere nodes int SphereAIndex = Spheres.IndexOf(portal.A); int SphereBIndex = Spheres.IndexOf(portal.B); // Index for the portal int PortalIndex = Portals.IndexOf(portal); // Links are all bidirectional SphereGraph.SetNodeArc(SphereAIndex, PortalIndex, SphereBIndex); SphereGraph.SetNodeArc(SphereBIndex, PortalIndex + BidirectionOffset, SphereAIndex); // Gotta show off that cool debugging Debug.DrawLine(portal.A.transform.position, portal.B.transform.position, Color.red, 1.0f); if (ShouldOperationYield()) { yield return(new WaitForEndOfFrame()); } } Debug.Log("Linked " + SphereGraph.numNodes + " spheres with " + SphereGraph.numArcs + " arcs"); yield return(null); }
public void RegularGraphTest(SimpleGraph graph, int diameter) { for (int h = 1; h <= diameter; h++) { SimpleVertexSignature sig0 = new SimpleVertexSignature(0, h, graph); string zeroCanonical = sig0.ToCanonicalString(); Console.Out.WriteLine(h + "\t" + zeroCanonical); for (int i = 1; i < graph.GetVertexCount(); i++) { SimpleVertexSignature sig = new SimpleVertexSignature(i, h, graph); // Assert.AreEqual(zeroCanonical, sig.ToCanonicalString()); string canString = sig.ToCanonicalString(); if (zeroCanonical.Equals(canString)) { // Console.Out.WriteLine("EQU"); } else { Console.Out.WriteLine("NEQ " + h + "\t" + i + "\t" + zeroCanonical + " " + canString); } Assert.AreEqual(zeroCanonical, canString); } } }
public void BreadthFirstSearch_5_Vertex_Where_path_has_2v() { int size = 5; SimpleGraph <int> testGraph = new SimpleGraph <int>(size); testGraph.AddVertex(0); // добавляем вершины testGraph.AddVertex(10); testGraph.AddVertex(20); testGraph.AddVertex(30); testGraph.AddVertex(40); testGraph.AddEdge(0, 1); // добавление рёбер между вершинами testGraph.AddEdge(0, 3); testGraph.AddEdge(0, 4); testGraph.AddEdge(1, 2); testGraph.AddEdge(2, 3); testGraph.AddEdge(3, 4); List <Vertex <int> > vList = testGraph.BreadthFirstSearch(0, 4); // попытка построения пути из 0 (0) в 4 (40). vList.ForEach((item) => Console.Write(" {0}", item.Value)); Assert.IsNotNull(vList); Assert.IsTrue(vList.Count == 2); }
private static bool HasPath(object adjacentRingA, object adjacentRingB, SimpleGraph <object> graph) { HashSet <object> visited = new HashSet <object>(); bool more = true; List <object> actives = new List <object>(); List <object> newActives = new List <object>(); actives.Add(adjacentRingB); while (more) { more = false; foreach (object cur in actives) { visited.Add(cur); object[] items = graph.GetAdjacent(cur); foreach (object o in items) { if (object.ReferenceEquals(o, adjacentRingA)) { return(true); } if (visited.Add(o)) { more = true; newActives.Add(o); } } } actives = newActives; newActives.Clear(); } return(false); }
public void AddEdge_in_5v_Graph_If_v1_Is_not_Exists() { int size = 5; SimpleGraph <int> testGraph = new SimpleGraph <int>(size); testGraph.AddVertex(19); testGraph.AddVertex(18); testGraph.AddVertex(17); testGraph.AddVertex(16); testGraph.AddEdge(0, 4); for (int i = 0; i < testGraph.m_adjacency.GetLength(0); i++) { for (int j = 0; j < testGraph.m_adjacency.GetLength(1); j++) { Console.Write(testGraph.m_adjacency[i, j] + " "); } Console.WriteLine(); } Assert.IsTrue(testGraph.vertex[0].Value == 19); // вершина не изменились Assert.IsTrue(testGraph.vertex[1].Value == 18); Assert.IsTrue(testGraph.vertex[2].Value == 17); Assert.IsTrue(testGraph.vertex[3].Value == 16); Assert.IsNull(testGraph.vertex[4]); // вершина не существует Assert.AreEqual(0, testGraph.m_adjacency[0, 4]); // ребро не добавлено к v0 Assert.AreEqual(0, testGraph.m_adjacency[4, 0]); // ребро не добавлено к v4 }
public void AddVertex_5v_in_5v_Graph() { int size = 5; SimpleGraph <int> testGraph = new SimpleGraph <int>(size); testGraph.AddVertex(19); testGraph.AddVertex(18); testGraph.AddVertex(17); testGraph.AddVertex(16); testGraph.AddVertex(15); Assert.IsTrue(testGraph.vertex[0].Value == 19); Assert.IsTrue(testGraph.vertex[1].Value == 18); Assert.IsTrue(testGraph.vertex[2].Value == 17); Assert.IsTrue(testGraph.vertex[3].Value == 16); Assert.IsTrue(testGraph.vertex[4].Value == 15); Assert.AreEqual(size, testGraph.max_vertex); Assert.AreEqual(size, testGraph.vertex.Length); Assert.AreEqual(size, testGraph.m_adjacency.GetLength(0)); Assert.AreEqual(size, testGraph.m_adjacency.GetLength(1)); Assert.AreEqual(0, testGraph.m_adjacency[0, 0]); Assert.AreEqual(0, testGraph.m_adjacency[1, 0]); Assert.AreEqual(0, testGraph.m_adjacency[2, 0]); Assert.AreEqual(0, testGraph.m_adjacency[3, 0]); Assert.AreEqual(0, testGraph.m_adjacency[4, 0]); }
public void AddVertex_1v_in_5v_Graph() { int size = 5; SimpleGraph <int> testGraph = new SimpleGraph <int>(5); testGraph.AddVertex(19); foreach (Vertex <int> item in testGraph.vertex) { if (item != null) { Console.Write(item.Value + ", "); } else { Console.Write("null, "); } } Assert.IsTrue(testGraph.vertex[0].Value == 19); Assert.AreEqual(size, testGraph.max_vertex); Assert.AreEqual(size, testGraph.vertex.Length); Assert.AreEqual(size, testGraph.m_adjacency.GetLength(0)); Assert.AreEqual(size, testGraph.m_adjacency.GetLength(1)); Assert.AreEqual(0, testGraph.m_adjacency[0, 0]); }
public void WeakVertices_in_3v_where_Graph_Is_Triangle() { int size = 3; SimpleGraph <int> testGraph = new SimpleGraph <int>(size); testGraph.AddVertex(0); // добавляем вершины testGraph.AddVertex(10); testGraph.AddVertex(20); testGraph.AddEdge(0, 1); // добавление рёбер между вершинами testGraph.AddEdge(0, 2); testGraph.AddEdge(1, 2); List <Vertex <int> > WeakList = testGraph.WeakVertices(); int expectedCount = 0; int actualCount = WeakList.Count; if (WeakList.Count != 0) { WeakList.ForEach((item) => Console.Write("{0} ", item.Value)); } else { Console.WriteLine("[]"); } Assert.IsNotNull(WeakList); Assert.AreEqual(expectedCount, actualCount); }
/// <summary> /// /// </summary> /// <param name="graph"></param> /// <param name="start"></param> private static void breadthFirstSearch(SimpleGraph graph, char start) { // 初始化队列 Queue queue = new Queue(); queue.Enqueue(start);//插入数据 Dictionary <char, bool> visited = new Dictionary <char, bool>(); visited[start] = true;//给字典对于键值对赋值 while (queue.Count != 0) { char current = (char)queue.Dequeue();//移除并返回队首元素 Console.WriteLine("队首元素: " + current); foreach (char next in graph.neighbors(current)) { //当next 不在visited中时 if (!visited.ContainsKey(next)) { queue.Enqueue(next); visited[next] = true; } } } }
static NAKANJ() { _knightMoveGraph = new SimpleGraph(vertexCount: 64); // The problem's chessboard has rows from 8 to 1 and columns from a to h, // starting in the upper left corner. This one will have rows from 0 to 7 // and columns from 0 to 7, starting in the upper left hand corner. for (int r = 0; r < 8; ++r) { for (int c = 0; c < 8; ++c) { int thisVertexID = GetVertexID(r, c); foreach (var knightMoveTransformation in _knightMoveTransformations) { int rowTransformation = knightMoveTransformation.Item1; int columnTransformation = knightMoveTransformation.Item2; int movedToVertexID; if (TryGetVertexID(r + rowTransformation, c + columnTransformation, out movedToVertexID)) { _knightMoveGraph.AddEdge(thisVertexID, movedToVertexID); } } } } }
public void TestDoubleBreadthA_1() { SimpleGraph <int> graph = GetGraphB(); List <Vertex <int> > list = graph.BreadthFirstSearch(2, 5); List <Vertex <int> > list2 = graph.BreadthFirstSearch(3, 8); List <Vertex <int> > list3 = graph.BreadthFirstSearch(1, 5); int[] array = new int[] { 2, 0, 4, 5 }; int[] array3 = new int[] { 1, 9, 5 }; int index = 0; foreach (Vertex <int> vert in list) { Assert.AreEqual(array[index++], vert.Value); } Assert.AreEqual(0, list2.Count); index = 0; foreach (Vertex <int> vert in list3) { Assert.AreEqual(array3[index++], vert.Value); } }
public void ValidatesAGraph1() { // This graph is a triangle. var graph = SimpleGraph.CreateFromZeroBasedEdges(3, new[, ] { { 0, 1 }, { 0, 2 }, { 1, 2 } }); Assert.AreEqual(2, graph.Vertices[0].Degree); Assert.AreEqual(2, graph.Vertices[1].Degree); Assert.AreEqual(2, graph.Vertices[2].Degree); Assert.IsTrue(graph.HasEdge(0, 1)); Assert.IsTrue(graph.HasEdge(1, 0)); Assert.IsTrue(graph.HasEdge(0, 2)); Assert.IsTrue(graph.HasEdge(1, 2)); Assert.IsFalse(graph.HasEdge(1, 1)); Assert.IsFalse(graph.Vertices[0].HasNeighbor(0)); Assert.IsTrue(graph.Vertices[0].HasNeighbor(1)); Assert.IsTrue(graph.Vertices[0].HasNeighbor(2)); Assert.IsTrue(graph.Vertices[1].HasNeighbor(0)); Assert.IsFalse(graph.Vertices[1].HasNeighbor(1)); Assert.IsTrue(graph.Vertices[1].HasNeighbor(2)); Assert.IsTrue(graph.Vertices[2].HasNeighbor(0)); Assert.IsTrue(graph.Vertices[2].HasNeighbor(1)); Assert.IsFalse(graph.Vertices[2].HasNeighbor(2)); }
// The only way to cover a leaf's edge is by choosing the leaf, or by choosing // its parent. Choosing its parent is better since that'll cover other edges // as well. This solution chooses leaf parents, and removes from the tree any // edges the leaf parent covers. As this removal process happens, new leaves // get created and set aside to work on. Once there are no more leaves left, // we're done. We know this works because assume we missed part of the tree. The // part is also a tree, so it has a leaf. This leaf wasn't one of the initial leaves, // otherwise we would've seen it already. So to be a leaf now it must've had an // edge removed, so it must've been a neighbor of one of the parent leaves, // so we must've seen it, contradiction. public static int Solve(SimpleGraph tree) { var leaves = new HashSet <Vertex>(tree.Vertices.Where(v => v.Degree == 1)); int vertexCoverSize = 0; while (leaves.Any()) { var leaf = leaves.First(); var parentLeaf = leaf.Neighbors.First(); var parentLeafNeighbors = parentLeaf.Neighbors.ToArray(); foreach (var parentLeafNeighor in parentLeafNeighbors) { tree.RemoveEdge(parentLeaf, parentLeafNeighor); if (parentLeafNeighor.Degree == 1) { leaves.Add(parentLeafNeighor); } else if (parentLeafNeighor.Degree == 0) { leaves.Remove(parentLeafNeighor); } } // Parent may have been a leaf, and its degree is 0 now, so try removing. leaves.Remove(parentLeaf); ++vertexCoverSize; } return(vertexCoverSize); }
public async Task TestSpec2SpecMapGeneratedByTypeChecker(SimpleGraph file2file) { var helper = new WorkspaceEvaluationHelper(TestOutputDirectory, null, forTesting: true); var repo = GenerateFullWorkspaceRepo(helper, file2file); var workspace = await helper.ParseAsync(repo); var semanticModel = helper.Typecheck(workspace); Func <int, AbsolutePath> specIdxToSpecPath = (specIdx) => SpecIdxToSpecPath(repo, specIdx); var relevantSpecPaths = file2file.Nodes.Select(specIdxToSpecPath).ToList(); Func <RoaringBitSet, IEnumerable <AbsolutePath> > materializeRelevant = (bitSet) => { bitSet.MaterializeSetIfNeeded(string.Empty, (s, i) => workspace.GetAllSourceFiles()[i].GetAbsolutePath(helper.PathTable)); return(bitSet.MaterializedSetOfPaths.Intersect(relevantSpecPaths)); }; // test the spec2spec map generated by TypeChecker XAssert.All( file2file.Nodes, specIdx => { var specSourceFile = workspace.GetSourceFile(SpecIdxToSpecPath(repo, specIdx)); var computedDependencies = materializeRelevant(semanticModel.GetFileDependenciesOf(specSourceFile)); var computedDependents = materializeRelevant(semanticModel.GetFileDependentFilesOf(specSourceFile)); var expectedDependents = file2file.OutgoingEdges(specIdx).Select(e => specIdxToSpecPath(e.Dest)); var expectedDependencies = file2file.IncomingEdges(specIdx).Select(e => specIdxToSpecPath(e.Src)); XAssert.SetEqual(expectedDependencies, computedDependents); XAssert.SetEqual(expectedDependents, computedDependencies); }); }
public static SimpleGraph MakeSandwich(int size) { SimpleGraph g = new SimpleGraph(); int center = size * 2; // face A for (int i = 0; i < size - 1; i++) { g.MakeEdge(i, i + 1); g.MakeEdge(i, center); } g.MakeEdge(size - 1, 0); g.MakeEdge(size - 1, center); // face B for (int i = 0; i < size - 1; i++) { g.MakeEdge(i + size, i + size + 1); g.MakeEdge(i + size, center); } g.MakeEdge((2 * size) - 1, size); g.MakeEdge((2 * size) - 1, center); return(g); }
public static SimpleGraph MakeGrotschGraph() { SimpleGraph g = new SimpleGraph(); g.MakeEdge(0, 1); g.MakeEdge(0, 2); g.MakeEdge(0, 3); g.MakeEdge(0, 4); g.MakeEdge(0, 5); g.MakeEdge(1, 7); g.MakeEdge(1, 10); g.MakeEdge(2, 6); g.MakeEdge(2, 8); g.MakeEdge(3, 7); g.MakeEdge(3, 9); g.MakeEdge(4, 8); g.MakeEdge(4, 10); g.MakeEdge(5, 6); g.MakeEdge(5, 9); g.MakeEdge(6, 7); g.MakeEdge(6, 10); g.MakeEdge(7, 8); g.MakeEdge(8, 9); g.MakeEdge(9, 10); return(g); }
public void TestAddED_RemoveED_3() { SimpleGraph graph = new SimpleGraph(4); graph.AddVertex(1); graph.AddVertex(2); graph.AddVertex(3); graph.AddVertex(4); graph.AddEdge(0, 1); graph.AddEdge(0, 2); graph.AddEdge(0, 3); graph.AddEdge(2, 3); Assert.IsFalse(graph.IsEdge(1, 3)); Assert.IsFalse(graph.IsEdge(1, 2)); Assert.IsTrue(graph.IsEdge(0, 1)); Assert.IsTrue(graph.IsEdge(0, 2)); Assert.IsTrue(graph.IsEdge(0, 3)); Assert.IsTrue(graph.IsEdge(2, 3)); graph.RemoveVertex(2); Assert.IsTrue(graph.vertex[2] == null); Assert.IsFalse(graph.IsEdge(0, 2)); Assert.IsFalse(graph.IsEdge(2, 0)); Assert.IsFalse(graph.IsEdge(3, 2)); }
public void TestAddED_RemoveED_5() { SimpleGraph graph = new SimpleGraph(3); graph.AddVertex(1); graph.AddVertex(2); graph.AddVertex(3); graph.AddEdge(0, 1); graph.AddEdge(0, 2); Assert.IsTrue(graph.m_adjacency[0, 1] == 1); Assert.IsTrue(graph.m_adjacency[0, 2] == 1); graph.RemoveEdge(0, 2); Assert.IsTrue(graph.m_adjacency[0, 1] == 1); Assert.IsTrue(graph.m_adjacency[0, 2] == 0); graph.AddEdge(2, 0); Assert.IsTrue(graph.m_adjacency[0, 1] == 1); Assert.IsTrue(graph.m_adjacency[0, 2] == 1); graph.RemoveEdge(2, 0); Assert.IsTrue(graph.m_adjacency[0, 1] == 1); Assert.IsTrue(graph.m_adjacency[2, 0] == 0); }
//Iterative depth-first search that returns the node with the target data. public static GraphNode <T> BFS <T>(this SimpleGraph <T> graph, T target) { if (graph == null || graph.Nodes.Count == 0) { return(null); } var visited = new HashSet <GraphNode <T> >(); var queue = new DataStructures.Queue <GraphNode <T> >(); queue.Enqueue(graph.Root); while (!queue.IsEmpty) { GraphNode <T> curr = queue.Dequeue(); if (visited.Contains(curr)) { continue; } if (curr.Data.Equals(target)) { return(curr); } visited.Add(curr); foreach (GraphNode <T> neighbor in curr.Neighbors) { queue.Enqueue(neighbor); } } return(null); }
public void TestBreadthA_Empty() { SimpleGraph <int> graph = GetGraphA(); List <Vertex <int> > list = graph.BreadthFirstSearch(7, 8); Assert.AreEqual(0, list.Count); }
/* * 0 1 2 3 4 5 6 7 8 9 * * * 0 0 1 1 0 1 0 0 0 0 0 * * 1 1 0 0 0 0 0 0 1 0 1 * * 2 1 0 0 1 0 0 0 0 0 0 * * 3 0 0 1 0 1 0 0 0 0 0 * * 4 1 0 0 1 0 1 0 0 0 0 * * 5 0 0 0 0 1 0 0 0 0 1 * * 6 0 0 0 0 0 0 0 1 0 1 * * 7 0 1 0 0 0 0 1 0 0 0 * * 8 0 0 0 0 0 0 0 0 0 0 * * 9 0 1 0 0 0 1 1 0 0 0 */ private SimpleGraph <int> GetGraphB() { SimpleGraph <int> graph = new SimpleGraph <int>(10); graph.AddVertex(0); graph.AddVertex(1); graph.AddVertex(2); graph.AddVertex(3); graph.AddVertex(4); graph.AddVertex(5); graph.AddVertex(6); graph.AddVertex(7); graph.AddVertex(8); graph.AddVertex(9); graph.AddEdge(0, 1); graph.AddEdge(0, 2); graph.AddEdge(0, 4); graph.AddEdge(1, 7); graph.AddEdge(1, 9); graph.AddEdge(2, 3); graph.AddEdge(3, 4); graph.AddEdge(4, 5); graph.AddEdge(5, 9); graph.AddEdge(6, 7); graph.AddEdge(6, 9); return(graph); }
private static void Main() { var output = new StringBuilder(); int testCount = FastIO.ReadNonNegativeInt(); for (int t = 1; t <= testCount; ++t) { int bugCount = FastIO.ReadNonNegativeInt(); int interactionCount = FastIO.ReadNonNegativeInt(); var interactionGraph = new SimpleGraph(bugCount); for (int i = 0; i < interactionCount; ++i) { interactionGraph.AddEdge( firstVertexID: FastIO.ReadNonNegativeInt() - 1, secondVertexID: FastIO.ReadNonNegativeInt() - 1); } output.AppendLine($"Scenario #{t}:"); output.AppendLine(BUGLIFE.Solve(interactionGraph) ? "No suspicious bugs found!" : "Suspicious bugs found!"); } Console.Write(output); }
public static void Main(string[] args) { var graph = new SimpleGraph <bool>(); var node1 = new SimpleGraphNode <bool>(1); var Node1Input1 = new SimpleGraphTerminal <bool>(node1); var Node1Input2 = new SimpleGraphTerminal <bool>(node1); var Node1Output = new SimpleGraphTerminal <bool>(node1); node1.Inputs.Add(Node1Input1); node1.Inputs.Add(Node1Input2); node1.Outputs.Add(Node1Output); var node2 = new SimpleGraphNode <bool>(2); var Node2Input1 = new SimpleGraphTerminal <bool>(node2); var Node2Output = new SimpleGraphTerminal <bool>(node2); node2.Inputs.Add(Node2Input1); node2.Outputs.Add(Node2Output); var node3 = new SimpleGraphNode <bool>(3); var Node3Input1 = new SimpleGraphTerminal <bool>(node3); var Node3Output = new SimpleGraphTerminal <bool>(node3); node3.Inputs.Add(Node3Input1); node3.Outputs.Add(Node3Output); var node4 = new SimpleGraphNode <bool>(4); var Node4Output = new SimpleGraphTerminal <bool>(node4); node4.Outputs.Add(Node4Output); var node5 = new SimpleGraphNode <bool>(5); var Node5Output = new SimpleGraphTerminal <bool>(node5); node5.Outputs.Add(Node5Output); var node6 = new SimpleGraphNode <bool>(6); var Node6Input1 = new SimpleGraphTerminal <bool>(node6); node6.Inputs.Add(Node6Input1); graph.AddNode(node1); graph.AddNode(node2); graph.AddNode(node3); graph.AddNode(node4); graph.AddNode(node5); graph.AddNode(node6); graph.AddEdge(new SimpleGraphEdge <bool>(Node3Output, Node6Input1)); graph.AddEdge(new SimpleGraphEdge <bool>(Node1Output, Node2Input1)); graph.AddEdge(new SimpleGraphEdge <bool>(Node2Output, Node3Input1)); graph.AddEdge(new SimpleGraphEdge <bool>(Node4Output, Node1Input1)); graph.AddEdge(new SimpleGraphEdge <bool>(Node5Output, Node1Input2)); graph.CalculateFromNode(node3); Console.ReadKey(); }
public void AddVertex() { var g = new SimpleGraph(10); g.AddVertex(1); g.AddVertex(2); Assert.True(!g.IsEdge(1, 2)); }
static PPATH() { // 10000 because zero-based indices. This isn't great as we don't need 10000 // (as most #s don't represent primes), but hopefully it doesn't matter. Edges // exist between primes (a vertex whose index is prime) and other primes, // when there's a one-digit swap to go between them (swaps are reversible). _primeGraph = new SimpleGraph(10000); var primeDecider = new SieveOfEratosthenesDecider(9999); // If n is a prime, connect to the primes greater than it, within a one-digit swap. Only // greater than because lesser primes were already connected to it earlier in the loop. for (int n = 1001; n <= 9999; n += 2) { if (!primeDecider.IsOddPrime(n)) continue; int nSwapped = n + 1000; while (nSwapped % 10000 > n) { if (primeDecider.IsOddPrime(nSwapped)) _primeGraph.AddEdge(n, nSwapped); nSwapped += 1000; } nSwapped = n + 100; while (nSwapped % 1000 > n % 1000) { if (primeDecider.IsOddPrime(nSwapped)) _primeGraph.AddEdge(n, nSwapped); nSwapped += 100; } nSwapped = n + 10; while (nSwapped % 100 > n % 100) { if (primeDecider.IsOddPrime(nSwapped)) _primeGraph.AddEdge(n, nSwapped); nSwapped += 10; } nSwapped = n + 2; while (nSwapped % 10 > n % 10) { if (primeDecider.IsOddPrime(nSwapped)) _primeGraph.AddEdge(n, nSwapped); nSwapped += 2; } } }
// For example, edges like (1, 2), (2, 3) => there's an edge between vertices 0 and 1 and 1 and 2. public static SimpleGraph CreateFromOneBasedEdges(int vertexCount, int[,] edges) { var graph = new SimpleGraph(vertexCount); for (int id = 0; id < vertexCount; ++id) { graph._vertices[id] = new Vertex(graph, id); } for (int i = 0; i < edges.GetLength(0); ++i) { graph.AddEdge(edges[i, 0] - 1, edges[i, 1] - 1); } return graph; }
internal Vertex(SimpleGraph graph, int ID) { _graph = graph; this.ID = ID; }