Merge pull request #58 from AjayZinngg/master

Author: abranhe

algorithms/greedy/Dijkstra.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Diagnostics;
+ 
+namespace DijkstraAlgorithm
+{
+    class Dijkstra
+    {
+ 
+        private static int MinimumDistance(int[] distance, bool[] shortestPathTreeSet, int verticesCount)
+        {
+            int min = int.MaxValue;
+            int minIndex = 0;
+ 
+            for (int v = 0; v < verticesCount; ++v)
+            {
+                if (shortestPathTreeSet[v] == false && distance[v] <= min)
+                {
+                    min = distance[v];
+                    minIndex = v;
+                }
+            }
+ 
+            return minIndex;
+        }
+ 
+        private static void OutputDistance(int[] distance, int verticesCount)
+        {
+            Console.WriteLine("Vertex Distance from source");
+ 
+            for (int i = 0; i < verticesCount; ++i)
+                Console.WriteLine("{0}\t  {1}", i, distance[i]);
+        }
+ 
+        public static void DijkstraAlgo(int[,] graph, int source, int verticesCount)
+        {
+            int[] distance = new int[verticesCount];
+            bool[] shortestPathTreeSet = new bool[verticesCount];
+ 
+            for (int i = 0; i < verticesCount; ++i)
+            {
+                distance[i] = int.MaxValue;
+                shortestPathTreeSet[i] = false;
+            }
+ 
+            distance[source] = 0;
+ 
+            for (int count = 0; count < verticesCount - 1; ++count)
+            {
+                int u = MinimumDistance(distance, shortestPathTreeSet, verticesCount);
+                shortestPathTreeSet[u] = true;
+ 
+                for (int v = 0; v < verticesCount; ++v)
+                    if (!shortestPathTreeSet[v] && Convert.ToBoolean(graph[u, v]) && distance[u] != int.MaxValue && distance[u] + graph[u, v] < distance[v])
+                        distance[v] = distance[u] + graph[u, v];
+            }
+ 
+            OutputDistance(distance, verticesCount);
+        }
+ 
+        static void Main(string[] args)
+        {
+            int[,] graph =  {
+                         { 0, 6, 0, 0, 0, 0, 0, 9, 0 },
+                         { 6, 0, 9, 0, 0, 0, 0, 11, 0 },
+                         { 0, 9, 0, 5, 0, 6, 0, 0, 2 },
+                         { 0, 0, 5, 0, 9, 16, 0, 0, 0 },
+                         { 0, 0, 0, 9, 0, 10, 0, 0, 0 },
+                         { 0, 0, 6, 0, 10, 0, 2, 0, 0 },
+                         { 0, 0, 0, 16, 0, 2, 0, 1, 6 },
+                         { 9, 11, 0, 0, 0, 0, 1, 0, 5 },
+                         { 0, 0, 2, 0, 0, 0, 6, 5, 0 }
+                            };
+ 
+            DijkstraAlgo(graph, 0, 9);
+        }
+    }
+}

algorithms/math/IterativePermutation.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Linq;
+ 
+public static class GeneratePermutationsIteratively
+{
+    public static void Main()
+    {
+        Console.WriteLine("Enter a number: ");
+        var num = int.Parse(Console.ReadLine());
+ 
+        var numberOfPerm = 1;
+        var elements = Enumerable.Range(1, num).ToArray();
+        var workArr = Enumerable.Range(0, elements.Length + 1).ToArray();
+ 
+        PrintPerm(elements);
+        var index = 1;
+        while (index < elements.Length)
+        {
+            workArr[index]--;
+            var j = 0;
+            if (index % 2 == 1)
+            {
+                j = workArr[index];
+            }
+ 
+            SwapInts(ref elements[j], ref elements[index]);
+            index = 1;
+            while (workArr[index] == 0)
+            {
+                workArr[index] = index;
+                index++;
+            }
+ 
+            numberOfPerm++;
+            PrintPerm(elements);
+        }
+ 
+        Console.WriteLine("Total permutations: {0}", numberOfPerm);
+    }
+ 
+    private static void PrintPerm(int[] elements)
+    {
+        Console.WriteLine(string.Join(", ", elements));
+    }
+ 
+    private static void SwapInts(ref int a, ref int b)
+    {
+        a ^= b;
+        b ^= a;
+        a ^= b;
+    }
+}