Exemplo n.º 1
0
    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);
    }
Exemplo n.º 2
0
    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 visited    = Enumerable.Range(0, n).Select(t => !gr[t].Any()).ToArray();
        var visitedCnt = visited.Count(t => t);
        var stack      = new Stack <Edge <long> >(gr[0]);
        var x          = Repeat(n, () => - 1L).ToArray();

        while (visitedCnt < n)
        {
            var i = Enumerable.Range(0, n).First(j => !visited[j]);
            gr[i].ForEach(stack.Push);

            while (stack.Any())
            {
                var edge = stack.Pop();
                if (!visited[edge.Target])
                {
                    x[edge.Target] = x[edge.Source] + edge.Cost;
                    gr[edge.Target].ForEach(stack.Push);
                    visited[edge.Target] = true;
                    visitedCnt++;
                }
            }
        }

        Repeat(m, j =>
        {
            if (x[r[j]] - x[l[j]] != d[j])
            {
                Answer(No);
            }
        });

        Answer(Yes);
    }
Exemplo n.º 3
0
 public void AddVertex(string name)
 {
     if (list.Contains(name) == false)
     {
         list.Add(new Vertex(name));
     }
 }
Exemplo n.º 4
0
        /// <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>
        /// Adds a new Node to graph
        /// </summary>
        /// <param name="value">value to add to graph</param>
        /// <returns>newly created node containing value</returns>
        public Vertex <T> AddNode(T value)
        {
            Vertex <T> node = new Vertex <T>(value);

            AdjacencyList.Add(node, new List <Edge <T> >());
            size++;

            return(node);
        }
Exemplo n.º 6
0
        public void AddToAdjacencyList(Tile t)
        {
            if (t == null)
            {
                return;
            }
            if (AdjacencyList == null)
            {
                AdjacencyList = new List <Tile>();
            }

            AdjacencyList.Add(t);
        }
Exemplo n.º 7
0
        public void buildAdjacencyList(int[][] edges)
        {
            //for(var adLs in graph.AdjacencyList)
            for (int i = 0; i < Verticies; i++)
            {
                AdjacencyList.Add(i, new List <int>());
            }

            for (int i = 0; i < edges.Length; i++)
            {
                addEdge(edges[i][0], edges[i][1]);
            }
        }
 public void AddNode(AbstractAdjacentGraphNode <TNode> graphNode)
 {
     if (graphNode == null)
     {
         throw new ArgumentNullException("graphNode");
     }
     if (DoesNodeExist(graphNode.Node))
     {
         throw new DuplicateNodeException(string.Format("The node {0} already exists and cannot be added!",
                                                        graphNode.Node));
     }
     AdjacencyList.Add(graphNode);
 }
Exemplo n.º 9
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="n"></param>
        public IEdge <KEY> AddAdjacentNode(INode <KEY> n)
        {
            if (n == null)
            {
                throw new ArgumentNullException("n");
            }

            IEdge <KEY> e = new Edge <KEY>(this, n);

            Edges.Add(new EdgeKey <KEY>(this.Key, n.Key), e);
            AdjacencyList.Add(n);
            return(e);
        }
Exemplo n.º 10
0
        public Graph AddNode(LocationNode node)
        {
            if (node == null)
            {
                return(this);
            }

            var contains = AdjacencyList.Any(list => list.Contains(node));

            if (contains)
            {
                return(this);
            }
            AdjacencyList.Add(new List <LocationNode> {
                node
            });
            return(this);
        }
Exemplo n.º 11
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="n"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        public IEdge <KEY> AddAdjacentNode(INode <KEY> n, IEdge <KEY> e)
        {
            if (n == null)
            {
                throw new ArgumentNullException("n");
            }

            if (e == null)
            {
                throw new ArgumentNullException("e");
            }

            e.SourceNode = this;
            e.TargetNode = n;
            Edges.Add(new EdgeKey <KEY>(this.Key, n.Key), e);
            AdjacencyList.Add(n);
            return(e);
        }
Exemplo n.º 12
0
        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");
            }
        }
Exemplo n.º 13
0
 /// <summary>
 /// Adds an edge based on the data in the passed-in EdgeToNeighbor instance.
 /// </summary>
 protected internal virtual void AddDirected(EdgeToNeighbor e)
 {
     neighbors.Add(e);
 }
Exemplo n.º 14
0
 public void AddToAdjList(HiddenMarkovState State)
 {
     AdjacencyList.Add(State);
 }
Exemplo n.º 15
0
 public void AddToAdjacencyList(Node node)
 {
     AdjacencyList.Add(node);
 }
Exemplo n.º 16
0
        public Graph()
        {
            var n0 = new Node(300, 300);
            var n1 = new Node("FFFF");
            var n2 = new Node("7834");
            var n3 = new Node("2834");

            //var n0 = new Node(124);
            //Console.WriteLine("An element ID: {0}", n0.ID);
            //var n1 = new Node(254);
            //Console.WriteLine("An element ID: {0}", n1.ID);
            //var n2 = new Node(172);
            //Console.WriteLine("An element ID: {0}", n2.ID);
            //var n3 = new Node(94);
            //Console.WriteLine("An element ID: {0}", n3.ID);
            //var n4 = new Node(47);
            //Console.WriteLine("An element ID: {0}", n4.ID);
            ////var n5 = new Node(49);
            ////Console.WriteLine("An element ID: {0}", n5.ID);
            //var n5 = new Node(2);
            //Console.WriteLine("An element ID: {0}", n5.ID);
            VertexList.Add(n0);
            VertexList.Add(n1);
            VertexList.Add(n2);
            VertexList.Add(n3);
            //VertexList.Add(n4);
            //VertexList.Add(n5);

            //Console.WriteLine();
            for (int i = 1; i < 51; i++)
            {
                var nn = new Node(i * 6 - 4);
                Console.WriteLine("An element ID: {0}", nn.ID);
                VertexList.Add(nn);
            }
            //Console.WriteLine();

            //Generate(VertexList.Count, 2);
            //AddEdge(0, 3);
            //AddEdge(1, 3);
            //AddEdge(2, 3);
            //AddEdge(3, 4);
            //AddEdge(4, 2);

            //AddEdge(0, 1);
            //AddEdge(0, 5);
            for (int i = 0; i < EdgeList.Count; i++)
            {
                AdjacencyList.Add(EdgeList[i].v1);
                HL.Add(-1);
            }


            for (int i = EdgeList.Count - 1; i >= 0; i--)
            {
                AdjacencyList.Add(EdgeList[i].v2);
            }
            for (int k = 0; k < AdjacencyList.Count; k++)
            {
                int i = AdjacencyList[k];
                LL.Add(HL[i]);
                HL[i] = k;
            }
            this.GraphWrite();

            //Console.WriteLine("Обход списка рёбер вершины 2");
            //int v = 2;
            //for(int k = HL[v]; k!=-1; k = LL[k])
            //{
            //    int j = AdjacencyList[AdjacencyList.Count - 1-k];
            //    Console.WriteLine("{0} - {1}", v, j);
            //}



            //foreach (Node v in VertexList)
            //{
            //    Console.WriteLine("\n\n\nNode IP: {0}, Node ID: {1}", v.ip, v.ID);
            //    v.WriteNeighboorhoodSet();
            //    int pref = v.ComparePrefixes(v.ID, VertexList[0].ID);
            //    // Console.WriteLine("\nPrefixes ID1: {0}, ID2: {1}, {2}", v.ID, VertexList[0].ID, pref);
            //    v.WriteLeafSet();
            //    v.WriteRoutingTable();
            //}
        }
Exemplo n.º 17
0
        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");
            }
        }
Exemplo n.º 18
0
 public Vertex AddVertex(Vertex vertex)
 {
     AdjacencyList.Add(vertex, new List <Vertex>());
     //return the added node
     return(Vertex);
 }
Exemplo n.º 19
0
 public void Add_Vertex_NoThrow()
 {
     Assert.DoesNotThrow(() => { adjList.Add(new VertexNode("A")); });
 }
Exemplo n.º 20
0
 protected virtual internal void AddLink(Link l)
 {
     neighbors.Add(l);
 }
Exemplo n.º 21
0
        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();
        }
Exemplo n.º 22
0
 /// <summary>
 /// Adds a new Adjacency Row to the Graph object and increments its count
 /// </summary>
 /// <param name="vertex">The vertex that will be the key for that adjacency row</param>
 private void AddNewAdjacencyRow(Vertex vertex)
 {
     AdjacencyList.Add(new AdjacencyRow(vertex));
     Count += 1;
 }