Exemplo n.º 1
0
        public static int[] DjikshtraAlgo(string source, GraphDS graph)
        {
            //Need to use priority queue
            // Will update with correct solution soon
            Queue <GraphNode> q = new Queue <GraphNode>();

            q.Enqueue(graph.vertices[graph.GetIndexOfVertex(source)]);
            int[] distance = new int[graph.vertices.Length];
            distance[graph.GetIndexOfVertex(graph.vertices[graph.GetIndexOfVertex(source)].label)] = 0;
            while (q.Count > 0)
            {
                GraphNode current = q.Dequeue();
                current.isVisited = true;
                GraphNode[] adjNodes = graph.GetAdjacentVertex(current.label);
                foreach (var node in adjNodes)
                {
                    if (!node.isVisited)
                    {
                        q.Enqueue(node);
                        node.isVisited = true;
                        distance[graph.GetIndexOfVertex(node.label)] = distance[graph.GetIndexOfVertex(current.label)] + 1;
                    }
                }
            }
            return(distance);
        }
Exemplo n.º 2
0
        public static int[] SSSPBFS(string source, GraphDS graph)
        {
            Queue <GraphNode> q = new Queue <GraphNode>();

            q.Enqueue(graph.vertices[graph.GetIndexOfVertex(source)]);
            int[] distance = new int[graph.vertices.Length];
            distance[graph.GetIndexOfVertex(graph.vertices[graph.GetIndexOfVertex(source)].label)] = 0;
            while (q.Count > 0)
            {
                GraphNode current = q.Dequeue();
                current.isVisited = true;
                GraphNode[] adjNodes = graph.GetAdjacentVertex(current.label);
                foreach (var node in adjNodes)
                {
                    if (!node.isVisited)
                    {
                        q.Enqueue(node);
                        node.isVisited = true;
                        distance[graph.GetIndexOfVertex(node.label)] = distance[graph.GetIndexOfVertex(current.label)] + 1;
                    }
                }
            }
            return(distance);
        }
Exemplo n.º 3
0
        public static void DepthFirstSearch(string source, GraphDS graph)
        {
            Console.WriteLine(source);

            graph.vertices[graph.GetIndexOfVertex(source)].isVisited = true;

            GraphNode[] adjNodes = graph.GetAdjacentVertex(source);

            foreach (var node in adjNodes)
            {
                if (!node.isVisited)
                {
                    DepthFirstSearch(node.label, graph);
                }
            }
        }
Exemplo n.º 4
0
        public static void BreadthFirstSearch(string source, GraphDS graph)
        {
            Queue <GraphNode> q = new Queue <GraphNode>();

            q.Enqueue(graph.vertices[graph.GetIndexOfVertex(source)]);

            while (q.Count > 0)
            {
                GraphNode temp = q.Dequeue();
                temp.isVisited = true;
                Console.WriteLine(temp.label);

                GraphNode[] adjNodes = graph.GetAdjacentVertex(temp.label);

                foreach (var node in adjNodes)
                {
                    if (!node.isVisited)
                    {
                        q.Enqueue(node);
                    }
                }
            }
        }
        public static int[] BellmanFordShortPath(string source, GraphDS graph)
        {
            distnace = new int[graph.numberOfVertices];

            for (int i = 0; i < graph.numberOfVertices; i++)
            {
                distnace[i] = Int32.MaxValue;
            }
            distnace[graph.GetIndexOfVertex(source)] = 0;

            for (int i = 0; i < graph.numberOfVertices; i++)
            {
                foreach (var edge in graph.edges)
                {
                    string start       = edge.source;
                    string destination = edge.destination;
                    int    cost        = edge.cost;

                    if (distnace[graph.GetIndexOfVertex(destination)] > distnace[graph.GetIndexOfVertex(start)] + cost)
                    {
                        distnace[graph.GetIndexOfVertex(destination)] = distnace[graph.GetIndexOfVertex(start)] + cost;
                    }
                }
            }
            foreach (var edge in graph.edges)
            {
                string start       = edge.source;
                string destination = edge.destination;
                int    cost        = edge.cost;

                if (distnace[graph.GetIndexOfVertex(destination)] > distnace[graph.GetIndexOfVertex(start)] + cost)
                {
                    Console.WriteLine("Negative cycle found");
                    break;
                }
            }
            return(distnace);
        }