chore(*): Move old solutions into a separate folder

2026-07-12 18:53:47 +00:00 · 2023-11-30 12:51:45 +00:00
parent ed3eb9cb54
commit b78d79a3af
117 changed files with 141 additions and 141 deletions
@@ -0,0 +1,124 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+// A C# program for Dijkstra1's single
+// source shortest path algorithm.
+// The program is for adjacency matrix
+// representation of the graph
+
+namespace Day15
+{
+    class Dijkstra1
+    {
+        // A utility function to find the
+        // vertex with minimum distance
+        // value, from the set of vertices
+        // not yet included in shortest
+        // path tree
+        static int V = 9;
+        int minDistance(int[] dist,
+                        bool[] sptSet)
+        {
+            // Initialize min value
+            int min = int.MaxValue, min_index = -1;
+
+            for (int v = 0; v < V; v++)
+                if (sptSet[v] == false && dist[v] <= min)
+                {
+                    min = dist[v];
+                    min_index = v;
+                }
+
+            return min_index;
+        }
+
+        // A utility function to print
+        // the constructed distance array
+        void printSolution(int[] dist, int n)
+        {
+            Console.Write("Vertex     Distance "
+                          + "from Source\n");
+            for (int i = 0; i < V; i++)
+                Console.Write(i + " \t\t " + dist[i] + "\n");
+        }
+
+        // Function that implements Dijkstra1's
+        // single source shortest path algorithm
+        // for a graph represented using adjacency
+        // matrix representation
+        public void dijkstra(int[,] graph, int src)
+        {
+            int[] dist = new int[V]; // The output array. dist[i]
+                                     // will hold the shortest
+                                     // distance from src to i
+
+            // sptSet[i] will true if vertex
+            // i is included in shortest path
+            // tree or shortest distance from
+            // src to i is finalized
+            bool[] sptSet = new bool[V];
+
+            // Initialize all distances as
+            // INFINITE and stpSet[] as false
+            for (int i = 0; i < V; i++)
+            {
+                dist[i] = int.MaxValue;
+                sptSet[i] = false;
+            }
+
+            // Distance of source vertex
+            // from itself is always 0
+            dist[src] = 0;
+
+            // Find shortest path for all vertices
+            for (int count = 0; count < V - 1; count++)
+            {
+                // Pick the minimum distance vertex
+                // from the set of vertices not yet
+                // processed. u is always equal to
+                // src in first iteration.
+                int u = minDistance(dist, sptSet);
+
+                // Mark the picked vertex as processed
+                sptSet[u] = true;
+
+                // Update dist value of the adjacent
+                // vertices of the picked vertex.
+                for (int v = 0; v < V; v++)
+
+                    // Update dist[v] only if is not in
+                    // sptSet, there is an edge from u
+                    // to v, and total weight of path
+                    // from src to v through u is smaller
+                    // than current value of dist[v]
+                    if (!sptSet[v] && graph[u, v] != 0 &&
+                         dist[u] != int.MaxValue && dist[u] + graph[u, v] < dist[v])
+                        dist[v] = dist[u] + graph[u, v];
+            }
+
+            // print the constructed distance array
+            printSolution(dist, V);
+        }
+
+        // Driver Code
+    //    public static void Main()
+    //    {
+    //        /* Let us create the example 
+    //graph discussed above */
+    //        int[,] graph = new int[,] { { 0, 4, 0, 0, 0, 0, 0, 8, 0 },
+    //                                  { 4, 0, 8, 0, 0, 0, 0, 11, 0 },
+    //                                  { 0, 8, 0, 7, 0, 4, 0, 0, 2 },
+    //                                  { 0, 0, 7, 0, 9, 14, 0, 0, 0 },
+    //                                  { 0, 0, 0, 9, 0, 10, 0, 0, 0 },
+    //                                  { 0, 0, 4, 14, 10, 0, 2, 0, 0 },
+    //                                  { 0, 0, 0, 0, 0, 2, 0, 1, 6 },
+    //                                  { 8, 11, 0, 0, 0, 0, 1, 0, 7 },
+    //                                  { 0, 0, 2, 0, 0, 0, 6, 7, 0 } };
+    //        Dijkstra1 t = new Dijkstra1();
+    //        t.dijkstra(graph, 0);
+    //    }
+    }
+}