private void bfs(Diagraph g, IEnumerable <int> sources)
        {
            Queue <int> q = new Queue <int>();

            for (int v = 0; v < g.V; v++)
            {
                distTo[v] = Int32.MaxValue;
            }

            foreach (int s in sources)
            {
                distTo[s] = 0;
                marked[s] = true;
                q.Enqueue(s);
            }

            while (q.Count != 0)
            {
                int v = q.Dequeue();

                foreach (var i in g.adj(v))
                {
                    if (!marked[i])
                    {
                        edgeTo[i] = v;
                        distTo[i] = distTo[v] + 1;
                        marked[i] = true;
                        q.Enqueue(i);
                    }
                }
            }
        }
        public void dfs(Diagraph g, int v)
        {
            marked[v]  = true;
            onStack[v] = true;
            foreach (int w in g.adj(v))
            {
                if (cycle != null)
                {
                    return;
                }

                if (!marked[w])
                {
                    edgeTo[w] = v;
                    dfs(g, w);
                }
                else if (onStack[w])
                {
                    //we have cycle
                    cycle = new Stack <int>();
                    int i = v;
                    for (; i != w; i = edgeTo[i])
                    {
                        cycle.Push(i);
                    }
                    cycle.Push(w);
                    cycle.Push(v);
                    return;
                }
            }

            onStack[v] = false;
        }
        public int[] distTo; // to keep level

        /// <summary>
        ///
        /// </summary>
        /// <param name="g"></param>
        /// <param name="s">Source</param>
        public DirectedBFS(Diagraph g, int s)
        {
            marked = new bool[g.V];
            edgeTo = new int[g.V];
            distTo = new int[g.V];

            bfs(g, s);
        }
        public DirectedBFS(Diagraph g, IEnumerable <int> sources)
        {
            marked = new bool[g.V];
            edgeTo = new int[g.V];
            distTo = new int[g.V];

            bfs(g, sources);
        }
Пример #5
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="g"></param>
        /// <param name="s">Source</param>
        public DirectedDFS(Diagraph g, int s)
        {
            marked = new bool[g.V];
            edgeTo = new int[g.V];

            marked[s] = true;
            edgeTo[s] = s;
            dfs(g, s);
        }
Пример #6
0
        public static void InternalMain()
        {
            Diagraph g = new Diagraph(@"Graph/testdata/tinyDG.txt");

            Console.Write(g.toString());

            //Graph g1 = g.Clone();
            //Console.Write(g1.toString());
        }
        public static void InternalMain()
        {
            Diagraph g = new Diagraph(@"Graph/testdata/TinyDAG.txt");

            Console.Write(g.toString());

            Topological t = new Topological(g);

            Console.WriteLine(Graph.PrintFormat(t.GetOrder()));
        }
Пример #8
0
        public static void InternalMain()
        {
            Diagraph g = new Diagraph(@"Graph/testdata/tinyDAG.txt");

            Console.Write(g.toString());

            KosarajuSharirSCC cc = new KosarajuSharirSCC(g);

            Console.WriteLine("Number of connected components" + cc.count());
            Console.WriteLine(cc.connected(3, 7));
        }
        public static void InternalMain()
        {
            Diagraph g = new Diagraph(@"Graph/testdata/tinyDG.txt");

            Console.Write(g.toString());

            DirectedCycle dc = new DirectedCycle(g);

            Console.WriteLine(dc.hasCycle());
            Console.WriteLine(Graph.PrintFormat(dc.Cycle()));
        }
Пример #10
0
 public void dfs(Diagraph g, int v)
 {
     marked[v] = true;
     foreach (int w in g.adj(v))
     {
         if (!marked[w])
         {
             edgeTo[w] = v;
             dfs(g, w);
         }
     }
 }
Пример #11
0
 public void dfs(Diagraph g, int v)
 {
     marked[v]      = true;
     connectedId[v] = connectedComponentCounter;
     foreach (int w in g.adj(v))
     {
         if (!marked[w])
         {
             dfs(g, w);
         }
     }
 }
Пример #12
0
        public static void InternalMain()
        {
            Diagraph g = new Diagraph(@"Graph/testdata/TinyDG.txt");

            Console.Write(g.toString());

            DirectedBFS bfsPths = new DirectedBFS(g, 6);

            Console.WriteLine(bfsPths.hasPathTo(3));
            Console.WriteLine(bfsPths.hasPathTo(1));
            Console.WriteLine(bfsPths.hasPathTo(7));
            Console.WriteLine(Graph.PrintFormat(bfsPths.pathTo(3)));
        }
Пример #13
0
        public DirectedDFS(Diagraph g, IEnumerable <int> sources)
        {
            marked = new bool[g.V];
            edgeTo = new int[g.V];

            foreach (var i in sources)
            {
                if (!marked[i])
                {
                    dfs(g, i);
                }
            }
        }
        public DirectedCycle(Diagraph g)
        {
            marked  = new bool[g.V];
            edgeTo  = new int[g.V];
            onStack = new bool[g.V];

            for (int i = 0; i < g.V; i++)
            {
                if (!marked[i] && cycle == null)
                {
                    dfs(g, i);
                }
            }
        }
Пример #15
0
        public KosarajuSharirSCC(Diagraph g)
        {
            marked      = new bool[g.V];
            connectedId = new int[g.V];

            DepthFirstOrder depthFirstOrder = new DepthFirstOrder(g);

            foreach (int i in depthFirstOrder.reversePost())
            {
                if (!marked[i])
                {
                    dfs(g, i);
                    connectedComponentCounter++;
                }
            }
        }
        // run DFS in digraph G from vertex v and compute preorder/postorder
        private void dfs(Diagraph G, int v)
        {
            marked[v] = true;
            preArr[v] = preCounter++;
            preorder.Enqueue(v);
            foreach (int w in G.adj(v))
            {
                if (!marked[w])
                {
                    dfs(G, w);
                }
            }

            postorder.Enqueue(v);
            postArr[v] = postCounter++;
        }
        private int postCounter;        // counter for postorder numbering

        /**
         * Determines a depth-first order for the digraph {@code G}.
         * @param G the digraph
         */

        public DepthFirstOrder(Diagraph G)
        {
            preArr    = new int[G.V];
            postArr   = new int[G.V];
            postorder = new Queue <int>();
            preorder  = new Queue <int>();
            marked    = new bool[G.V];

            for (int v = 0; v < G.V; v++)
            {
                if (!marked[v])
                {
                    dfs(G, v);
                }
            }
        }
Пример #18
0
        public Topological(Diagraph G)
        {
            DirectedCycle finder = new DirectedCycle(G);

            if (!finder.hasCycle())
            {
                DepthFirstOrder dfs = new DepthFirstOrder(G);
                order   = dfs.reversePost();
                rankArr = new int[G.V];
                int i = 0;
                foreach (int v in order)
                {
                    rankArr[v] = i++;
                }
            }
        }
Пример #19
0
        public Diagraph reverse()
        {
            Diagraph reverseDiagraph = new Diagraph(this.V);

            int index = 0;

            foreach (var list in bag)
            {
                foreach (int i in list)
                {
                    reverseDiagraph.addEdge(i, index);
                }
                index++;
            }

            return(reverseDiagraph);
        }