internal void Calculate()
        {
            IntBinaryHeapPriorityQueue pq=new IntBinaryHeapPriorityQueue(graph.NumberOfVertices);
              foreach(int s in source)
            pq.insert(s,0);

            while(!pq.isEmpty())
            {
              int u=pq.del_min();

              foreach(Edge l in graph.EdgesAtVertex(u))
            {
              int v=l.target;
              int len=l.weight;
              int c=dist[u]+len;

              if(pred[v]==null && !sourceSet.Contains(v))
                pq.insert(v,c);
              else if (c<dist[v])
                pq.decrease_priority(v,c);
              else
                continue;

              dist[v]=c; pred[v]=l;
            }
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Performs the main calculation.
        /// </summary>
        internal void Calculate()
        {
            IntBinaryHeapPriorityQueue pq = new IntBinaryHeapPriorityQueue(graph.NumberOfVertices);

            pq.insert(source, 0);
            while (!pq.isEmpty())
            {
                int u = pq.del_min();


                foreach (Edge l in graph.EdgesAtVertex(u))
                {
                    int v   = l.target;
                    int len = l.weight;
                    int c   = dist[u] + len;

                    if (pred[v] == null && v != source)
                    {
                        pq.insert(v, c);
                    }
                    else if (c < dist[v])
                    {
                        pq.decrease_priority(v, c);
                    }
                    else
                    {
                        continue;
                    }

                    dist[v] = c; pred[v] = l;
                }
            }
        }
Esempio n. 3
0
        void calc()
        {
            if (calcIsCalled)
            {
                return;
            }

            calcIsCalled = true;

            int  upperBound      = 0;      //the init is not needed but the compiler produces an error
            bool upperBoundIsSet = false;

            IntBinaryHeapPriorityQueue pq1 = new IntBinaryHeapPriorityQueue(graph.NumberOfVertices);

            pq1.insert(source, 0);
            while (!pq1.isEmpty())
            {
                int u = pq1.del_min();
                if (freeVertices[u])
                {
                    foundFreeVertex = u;
                    break;
                }

                foreach (Edge l in graph.EdgesAtVertex(u))
                {
                    int v   = l.target;
                    int len = l.weight;
                    int c   = dist[u] + len;
                    if (upperBoundIsSet && c >= upperBound)
                    {
                        continue;
                    }

                    if (freeVertices[v])
                    {
                        upperBound = c; upperBoundIsSet = true;
                    }

                    if (pred[v] == null && v != source)
                    {
                        pq1.insert(v, c);
                    }
                    else if (c < dist[v])
                    {
                        pq1.decrease_priority(v, c);
                    }
                    else
                    {
                        continue;
                    }

                    dist[v] = c; pred[v] = l;
                }
            }
        }
        /// <summary>
        /// Returns  a  path
        /// </summary>
        /// <returns></returns>
        internal Edge[] GetPath()
        {
            if(thePath!=null)return thePath;

            IntBinaryHeapPriorityQueue pq=new IntBinaryHeapPriorityQueue(graph.NumberOfVertices);
            pq.insert(source,0);
            while(!pq.isEmpty())
            {
                int u=pq.del_min();
                if(u==target)
                    break;

                foreach(Edge l in graph.EdgesAtVertex(u))
                {
                    int v=l.target;
                    int len=l.weight;
                    int c=dist[u]+len;
                    if(c > udist)continue;

                    if(pred[v]==null && v !=source)
                        pq.insert(v,c);
                    else if (c<dist[v])
                        pq.decrease_priority(v,c);
                    else
                        continue;

                    dist[v]=c; pred[v]=l;
                }
            }
            if(dist[target]==Graph.INF)
                throw new InvalidOperationException("target is not reached");

            {
            int count=0;
            int v=target;
            while(v!=source)
            {
                v=pred[v].source;
                count++;
            }
            thePath=new Edge[count];

            v=target;
            while(v!=source)
            {
                thePath[--count]=pred[v];
                v=pred[v].source;
            }

            }

            return thePath;
        }
Esempio n. 5
0
        void calcDistancesFromVertex(int indexInNeg,
                                     bool[] posC,
                                     int [,] dist,
                                     ref int maxdist)
        {
            int node = neg[indexInNeg];

            int [] ld = new int[n];          //local distance array
            IntBinaryHeapPriorityQueue pq1 = new IntBinaryHeapPriorityQueue(n);

            int posLeft = pos.Length;

            pq1.insert(node, 0);
            for (int i = 0; i < n; i++)
            {
                ld[i] = Graph.INF;
            }

            ld[node] = 0;

            while (!pq1.isEmpty())
            {
                int u = pq1.del_min();
                if (posC[u])
                {
                    if (--posLeft == 0)
                    {
                        break;
                    }
                }

                foreach (Edge l in this.linksByVertex[u])
                {
                    int v   = l.target;
                    int len = l.weight;
                    int c   = ld[u] + len;

                    if (ld[v] == Graph.INF)
                    {
                        pq1.insert(v, c);
                    }
                    else if (c < ld[v])
                    {
                        pq1.decrease_priority(v, c);
                    }
                    else
                    {
                        continue;
                    }

                    ld[v] = c;
                }
            }

            if (posLeft > 0)
            {
                throw new InvalidOperationException("graph is not strongly connected");
            }
            //put the results in dist and update maxdist
            for (int i = 0; i < pos.Length; i++)
            {
                int dis = dist[indexInNeg, i] = ld[pos[i]];
                if (dis > maxdist)
                {
                    maxdist = dis;
                }
            }
        }
Esempio n. 6
0
        void calcDistancesFromVertex(int indexInNeg, 
            bool[] posC,
            int [,]dist,
            ref int maxdist)
        {
            int node=neg[indexInNeg];
            int [] ld=new int[n];//local distance array
            IntBinaryHeapPriorityQueue pq1=new IntBinaryHeapPriorityQueue(n);

            int posLeft=pos.Length;
            pq1.insert(node,0);
            for(int i=0;i<n;i++)
                ld[i]=Graph.INF;

            ld[node]=0;

            while( ! pq1.isEmpty())
                {
                    int u=pq1.del_min();
                    if(posC[u])
                        {
                            if (--posLeft==0)
                                break;
                        }

                    foreach(Edge l in this.linksByVertex[u])
                        {
                            int v=l.target;
                            int len=l.weight;
                            int c=ld[u]+len;

                            if(ld[v]==Graph.INF)
                                pq1.insert(v,c);
                            else if (c<ld[v])
                                pq1.decrease_priority(v,c);
                            else
                                continue;

                            ld[v]=c;
                        }
                }

            if (posLeft>0)
                throw new InvalidOperationException("graph is not strongly connected");
            //put the results in dist and update maxdist
            for(int i=0;i<pos.Length;i++)
                {
                    int dis=dist[indexInNeg,i]=ld[pos[i]];
                    if (dis>maxdist)
                        maxdist=dis;
                }
        }
Esempio n. 7
0
        void calc()
        {
            if(calcIsCalled)
                 return;

             calcIsCalled=true;

             int upperBound=0; //the init is not needed but the compiler produces an error
             bool upperBoundIsSet=false;

             IntBinaryHeapPriorityQueue pq1=new IntBinaryHeapPriorityQueue(graph.NumberOfVertices);

             pq1.insert(source,0);
             while( ! pq1.isEmpty())
             {
                 int u=pq1.del_min();
                 if(freeVertices[u])
                 {
                     foundFreeVertex=u;
                     break;
                 }

                 foreach(Edge l in graph.EdgesAtVertex(u))
                 {

               int v=l.target;
                     int len=l.weight;
                     int c=dist[u]+len;
                     if(upperBoundIsSet && c >= upperBound)
                         continue;

                     if(freeVertices[v]){upperBound=c;upperBoundIsSet=true;}

                     if(pred[v]==null && v !=source)
                         pq1.insert(v,c);
                     else if (c<dist[v])
                         pq1.decrease_priority(v,c);
                     else
                         continue;

                     dist[v]=c; pred[v]=l;

                 }
             }
        }
        /// <summary>
        /// Returns  a  path
        /// </summary>
        /// <returns></returns>
        internal Edge[] GetPath()
        {
            if (thePath != null)
            {
                return(thePath);
            }

            IntBinaryHeapPriorityQueue pq = new IntBinaryHeapPriorityQueue(graph.NumberOfVertices);

            pq.insert(source, 0);
            while (!pq.isEmpty())
            {
                int u = pq.del_min();
                if (u == target)
                {
                    break;
                }

                foreach (Edge l in graph.EdgesAtVertex(u))
                {
                    int v   = l.target;
                    int len = l.weight;
                    int c   = dist[u] + len;
                    if (c > udist)
                    {
                        continue;
                    }

                    if (pred[v] == null && v != source)
                    {
                        pq.insert(v, c);
                    }
                    else if (c < dist[v])
                    {
                        pq.decrease_priority(v, c);
                    }
                    else
                    {
                        continue;
                    }

                    dist[v] = c; pred[v] = l;
                }
            }
            if (dist[target] == Graph.INF)
            {
                throw new InvalidOperationException("target is not reached");
            }

            {
                int count = 0;
                int v     = target;
                while (v != source)
                {
                    v = pred[v].source;
                    count++;
                }
                thePath = new Edge[count];

                v = target;
                while (v != source)
                {
                    thePath[--count] = pred[v];
                    v = pred[v].source;
                }
            }

            return(thePath);
        }