public DijkstraSP(EdgeWeightedDigraph g, int s)
        {
            foreach (DirectedEdge e in g.Edges())
            {
                if (e.Weight() < 0)
                {
                    throw new ArgumentOutOfRangeException("graph edge must have nonegative weights");
                }
            }

            distTo = new double[g.V];
            edgeTo = new DirectedEdge[g.V];
            for (int v = 0; v < g.V; v++)
            {
                distTo[v] = double.PositiveInfinity;
            }
            distTo[s] = 0;

            //relax vertices in order of distance from s
            pq = new IndexMinPQ <double>(g.V);
            pq.Insert(s, distTo[s]);
            while (!pq.IsEmpty())
            {
                int v = pq.DelMin();
                foreach (DirectedEdge e in g.Adj(v))
                {
                    relax(e);
                }
            }
        }
        public LazyPrimMinSpanningTree(EdgeWeightedGraph g)
        {
            pq     = new IndexMinPQ <Edge>(g.EdgeCount);
            marked = new bool[g.VertexCount];
            mst    = new Queue <Edge>();

            Visit(g, 0);
            while (!pq.IsEmpty())
            {
                Edge e  = pq.DelMin();
                int  v1 = e.CurrentValue;
                int  v2 = e.Other(v1);
                if (marked[v1] && marked[v2])
                {
                    continue;
                }

                mst.Enqueue(e);
                if (marked[v1])
                {
                    Visit(g, v1);
                }

                if (!marked[v2])
                {
                    Visit(g, v2);
                }
            }
        }
Ejemplo n.º 3
0
        private readonly IndexMinPQ<Double> _pq; // priority queue of vertices

        #endregion Fields

        #region Constructors

        /// <summary>
        /// Computes a shortest-paths tree from the source vertex <tt>s</tt> to every
        /// other vertex in the edge-weighted graph <tt>G</tt>.
        /// </summary>
        /// <param name="g">g the edge-weighted graph</param>
        /// <param name="s">s the source vertex</param>
        /// <exception cref="ArgumentException">if an edge weight is negative</exception>
        /// <exception cref="ArgumentException">unless 0 &lt;= <tt>s</tt> &lt;= <tt>V</tt> - 1</exception>
        public DijkstraUndirectedSP(EdgeWeightedGraph g, int s)
        {
            foreach (var e in g.Edges())
            {
                if (e.Weight < 0)
                    throw new ArgumentException($"edge {e} has negative weight");
            }

            _distTo = new double[g.V];
            _edgeTo = new EdgeW[g.V];
            for (var v = 0; v < g.V; v++)
                _distTo[v] = double.PositiveInfinity;
            _distTo[s] = 0.0;

            // relax vertices in order of distance from s
            _pq = new IndexMinPQ<Double>(g.V);
            _pq.Insert(s, _distTo[s]);
            while (!_pq.IsEmpty())
            {
                var v = _pq.DelMin();
                foreach (var e in g.Adj(v))
                    Relax(e, v);
            }

            // check optimality conditions
            //assert check(G, s);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Dijkstra algorithm (shortest path) based on graph g for start vertice s. Positive cycles are allowed in shortest path algorithm
        /// </summary>
        /// <param name="g">Graph for search</param>
        /// <param name="s">Start vertice</param>
        public static PathStats ShortestPath(GraphBase g, int s)
        {
            var ps = new PathStats(g.V);

            for (var i = 0; i < ps.Dist.Length; i++)
            {
                ps.Dist[i] = int.MaxValue;
                ps.Prev[i] = -1;
            }

            ps.Dist[s] = 0;//start vertice

            var pq = new IndexMinPQ<Distance>(ps.Dist.Length);
            for (int i = 0; i < ps.Dist.Length; i++)
            {
                pq.Insert(i, new Distance { V = i, Dist = ps.Dist[i] });
            }

            while (!pq.IsEmpty())
            {
                var v = pq.DelRoot();

                foreach (var e in g.Adjacent(v))
                {
                    if (ps.Dist[e.V2] > ps.Dist[v] + e.Weight)
                    {
                        ps.Dist[e.V2] = ps.Dist[v] + e.Weight;
                        ps.Prev[e.V2] = v;
                        pq.ChangeKey(e.V2, new Distance { V = e.V2, Dist = ps.Dist[e.V2] });
                    }
                }
            }

            return ps;
        }
Ejemplo n.º 5
0
        private readonly IndexMinPQ <Double> _pq;   // priority queue of vertices

        /// <summary>
        /// Computes a shortest-paths tree from the source vertex <tt>s</tt> to every other
        /// vertex in the edge-weighted digraph <tt>G</tt>.
        /// </summary>
        /// <param name="g">g the edge-weighted digraph</param>
        /// <param name="s">s the source vertex</param>
        /// <exception cref="ArgumentException">if an edge weight is negative</exception>
        /// <exception cref="ArgumentException">unless 0 &lt;= <tt>s</tt> &lt;= <tt>V</tt> - 1</exception>
        public DijkstraSP(EdgeWeightedDigraph g, int s)
        {
            foreach (var e in g.Edges())
            {
                if (e.Weight < 0)
                {
                    throw new ArgumentException($"edge {e} has negative weight");
                }
            }

            _distTo = new double[g.V];
            _edgeTo = new DirectedEdge[g.V];
            for (var v = 0; v < g.V; v++)
            {
                _distTo[v] = double.PositiveInfinity;
            }
            _distTo[s] = 0.0;

            // relax vertices in order of distance from s
            _pq = new IndexMinPQ <Double>(g.V);
            _pq.Insert(s, _distTo[s]);
            while (!_pq.IsEmpty())
            {
                var v = _pq.DelMin();
                foreach (var e in g.Adj(v))
                {
                    Relax(e);
                }
            }

            // check optimality conditions
            //assert check(G, s);
        }
Ejemplo n.º 6
0
 private void prim(EdgeWeightedGraph g, int s)
 {
     distTo[s] = 0.0;
     pq.Insert(s, distTo[s]);
     while (!pq.IsEmpty())
     {
         int v = pq.DelMin();
         scan(g, v);
     }
 }
Ejemplo n.º 7
0
 /// <summary>
 /// run Prim's algorithm in graph G, starting from vertex s
 /// </summary>
 /// <param name="g"></param>
 /// <param name="s"></param>
 private void Prim(EdgeWeightedGraph g, int s)
 {
     _distTo[s] = 0.0;
     _pq.Insert(s, _distTo[s]);
     while (!_pq.IsEmpty())
     {
         var v = _pq.DelMin();
         Scan(g, v);
     }
 }
Ejemplo n.º 8
0
        public DifkstraSP(EdgeWeightedDigraph g, int s)
        {
            _edgeTo    = new DirectedEdge[g.V];
            _distTo    = Enumerable.Repeat(double.PositiveInfinity, g.V).ToArray();
            _pq        = new IndexMinPQ <double>(g.V);
            _distTo[s] = 0.0;

            _pq.Insert(s, 0.0);
            while (!_pq.IsEmpty())
            {
                Relax(g, _pq.DelMin());
            }
        }
Ejemplo n.º 9
0
        public DijkstraAlgorithm(EdgeWeightedDigraph digraph, int source) : base(digraph, source)
        {
            //pq maintain a set of vertex need to deal with.
            IndexMinPQ <double> pq = new IndexMinPQ <double>(digraph.V);

            pq.Insert(source, distTo[source]);

            while (!pq.IsEmpty())
            {
                //when v pops up, the distance and path to v have been confirmed
                int v = pq.DelMin();
                foreach (DirectedEdge e in digraph.Adj(v))
                {
                    Relax(pq, e);
                }
            }
        }
Ejemplo n.º 10
0
        public PrimMinSpanningTree(EdgeWeightedGraph g)
        {
            edgeTo     = new Edge[g.VertexCount];
            distanceTo = new double[g.VertexCount];
            marked     = new bool[g.VertexCount];
            pq         = new IndexMinPQ <double>(g.VertexCount);
            for (int i = 0; i < g.VertexCount; i++)
            {
                distanceTo[i] = double.MaxValue;
            }

            distanceTo[0] = 0;
            pq.Insert(0, 0);
            while (!pq.IsEmpty())
            {
                Visit(g, pq.DeleteMin());
            }
        }
Ejemplo n.º 11
0
        private readonly decimal[] _distTo; // distTo[v] = distance  of shortest s->v path

        #endregion Fields

        #region Constructors

        /**
         * Computes a shortest paths tree from <tt>s</tt> to every other vertex in
         * the edge-weighted digraph <tt>G</tt>.
         * @param G the edge-weighted digraph
         * @param s the source vertex
         * @throws IllegalArgumentException if an edge weight is negative
         * @throws IllegalArgumentException unless 0 &le; <tt>s</tt> &le; <tt>V</tt> - 1
         */
        public ShortestNeuronPath(NeuronGraph G, int s)
        {
            _distTo = new decimal[G.V()];
            edgeTo = new DirectedEdge[G.V()];
            for (int v = 0; v < G.V(); v++)
                _distTo[v] = decimal.MaxValue;
            _distTo[s] = 0.0M;

            // relax vertices in order of distance from s
            pq = new IndexMinPQ<decimal>(G.V());
            pq.Insert(s, _distTo[s]);
            while (!pq.IsEmpty())
            {
                int v = pq.DelMin();
                foreach (DirectedEdge e in G.adj(v))
                    relax(e);
            }
        }
Ejemplo n.º 12
0
        void IndexMinPQTest()
        {
            var strArr = FileHandler.ReadFileAsStrArr("words3.txt");

            strArr.Show();
            var pq = new IndexMinPQ <string>(strArr.Length);

            for (int i = 0; i < strArr.Length; i++)
            {
                pq.Insert(i, strArr[i]);
            }
            while (!pq.IsEmpty())
            {
                Console.WriteLine(pq.DelMin());
            }
            Console.WriteLine();
            Console.ReadKey();
        }
Ejemplo n.º 13
0
        public DijkstraShortestPath(EdgeWeightedDirectedGraph graph, int start)
        {
            EdgeTo = new DirectedEdge[graph.VertexCount];
            DistTo = new double[graph.VertexCount];
            pq     = new IndexMinPQ <double>(graph.VertexCount);

            for (int i = 0; i < graph.VertexCount; i++)
            {
                DistTo[i]     = double.PositiveInfinity;
                DistTo[start] = 0;

                pq.Insert(start, 0);
                while (!pq.IsEmpty())
                {
                    Relax(graph, pq.DeleteMin());
                }
            }
        }
Ejemplo n.º 14
0
        public DijkstraSP(EdgeWeightedDigraph graph, int startVertex)
        {
            edgeTo        = new DirectedEdge[graph.Vertices];
            distTo        = new double[graph.Vertices];
            priorityQueue = new IndexMinPQ <double>(graph.Vertices);

            for (int v = 0; v < graph.Vertices; v++)
            {
                distTo[v] = double.MaxValue;
            }

            distTo[startVertex] = 0.0f;

            priorityQueue.Insert(startVertex, 0.0f);

            while (!priorityQueue.IsEmpty())
            {
                Relax(graph, priorityQueue.DelMin());
            }
        }
Ejemplo n.º 15
0
        public KruskalMinSpanningTree(EdgeWeightedGraph g)
        {
            mst = new Queue <Edge>();
            IndexMinPQ <Edge> pq = new IndexMinPQ <Edge>(g.EdgeCount);
            UnionFind_1       uf = new UnionFind_1(g.VertexCount);

            while (!pq.IsEmpty() && mst.Count < g.VertexCount - 1)
            {
                Edge e  = pq.DelMin();
                int  v1 = e.V1;
                int  v2 = e.Other(v1);
                if (uf.Connected(v1, v2))
                {
                    continue;
                }

                uf.Union(v1, v2);
                mst.Enqueue(e);
            }
        }
Ejemplo n.º 16
0
 public void DifkstraSPMy(EdgeWeightedDigraph g, int s)
 {
     _edgeTo    = new DirectedEdge[g.V];
     _distTo    = Enumerable.Repeat(double.PositiveInfinity, g.V).ToArray();
     _distTo[s] = 0.0;
     _pq        = new IndexMinPQ <double>(g.V);
     foreach (var e in g.Adj(s))
     {
         _edgeTo[e.To] = e;
         _distTo[e.To] = e.Weight;
         _pq.Insert(e.To, e.Weight);
     }
     while (!_pq.IsEmpty())
     {
         var i = _pq.DelMin();
         foreach (var e in g.Adj(i))
         {
             RelaxMy(i, e);
         }
     }
 }
Ejemplo n.º 17
0
        public DijkstraSP(EdgeWeightedDiagraph g, int source)
        {
            vertexNumber = g.V();
            distTo       = new double[vertexNumber];
            for (int i = 0; i < vertexNumber; i++)
            {
                distTo[i] = double.PositiveInfinity;
            }
            distTo[source] = 0.0;

            edgeTo = new DirectedEdge[vertexNumber];

            pq = new IndexMinPQ <double>(vertexNumber);
            pq.Insert(source, 0.0);

            while (!pq.IsEmpty())
            {
                int current = pq.DelMin();
                Relax(g, current);
            }
        }
Ejemplo n.º 18
0
        public PrimMst(EdgeWeightedGraph graph)
        {
            edgeTo = new Edge[graph.Vertices];
            distTo = new double[graph.Vertices];
            marked = new bool[graph.Vertices];

            for (int vertex = 0; vertex < graph.Vertices; vertex++)
            {
                distTo[vertex] = double.MaxValue;
            }

            prioryQueue = new IndexMinPQ <double>(graph.Vertices);

            distTo[0] = 0.0f;
            prioryQueue.Insert(0, 0.0f);

            while (!prioryQueue.IsEmpty())
            {
                Visit(graph, prioryQueue.DelMin());
            }
        }
Ejemplo n.º 19
0
 //ctor inits DSs, builds shortest path tree and computes distances
 //takes a built DiGraph and a source vertex
 public DijkstrasShortestPath(EdgeWeightedDiGraph g, int s)
 {
     _pq     = new IndexMinPQ <double>(g.V);
     _edgeTo = new DirectedEdge[g.V];
     _distTo = new double[g.V];
     //load initial values
     for (int i = 1; i < g.V; i++)
     {
         _distTo[i] = Double.PositiveInfinity;
     }
     _distTo[s] = 0.0;
     _edgeTo[s] = null;
     //loads a starting value onto PQ to start process
     _pq.Insert(s, _distTo[s]);
     //start business logic
     //start cycle of deleting min edges and checking adj edges for 'eligability'
     while (!_pq.IsEmpty())
     {
         var minV = _pq.DelMin();
         Relax(g, minV);
     }
 }