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

old/2021/15/Dijkstra.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Day15
+{
+    public class Dijkstra
+    {
+        public object PartOne(string input) => Solve(GetRiskLevelMap(input));
+        public object PartTwo(string input) => Solve(ScaleUp(GetRiskLevelMap(input)));
+
+        int Solve(Dictionary<Point, int> riskMap)
+        {
+            // Disjktra algorithm
+
+            var topLeft = new Point(0, 0);
+            var bottomRight = new Point(riskMap.Keys.MaxBy(p => p.x).x, riskMap.Keys.MaxBy(p => p.y).y);
+
+            // Visit points in order of cumulted risk
+            // ⭐ .Net 6 finally has a PriorityQueue collection :)
+            var q = new PriorityQueue<Point, int>();
+            var totalRiskMap = new Dictionary<Point, int>();
+
+            totalRiskMap[topLeft] = 0;
+            q.Enqueue(topLeft, 0);
+
+            // It would be enough to go until we find the bottom right corner, but computing all 
+            // risk levels is not much more work 
+            while (q.Count > 0)
+            {
+                var p = q.Dequeue();
+
+                foreach (var n in Neighbours(p))
+                {
+                    if (riskMap.ContainsKey(n) && !totalRiskMap.ContainsKey(n))
+                    {
+                        var totalRisk = totalRiskMap[p] + riskMap[n];
+                        totalRiskMap[n] = totalRisk;
+                        if (n == bottomRight)
+                        {
+                            break;
+                        }
+                        var h = 0; //bottomRight.y - n.y + bottomRight.x - n.x;
+                        q.Enqueue(n, totalRisk + h);
+                    }
+                }
+            }
+
+            // return bottom right corner's total risk:
+            return totalRiskMap[bottomRight];
+        }
+
+        // Create an 5x scaled up map, as described in part 2
+        Dictionary<Point, int> ScaleUp(Dictionary<Point, int> map)
+        {
+            var (ccol, crow) = (map.Keys.MaxBy(p => p.x).x + 1, map.Keys.MaxBy(p => p.y).y + 1);
+
+            var res = new Dictionary<Point, int>(
+                from y in Enumerable.Range(0, crow * 5)
+                from x in Enumerable.Range(0, ccol * 5)
+
+                    // x, y and risk level in the original map:
+            let tileY = y % crow
+                let tileX = x % ccol
+                let tileRiskLevel = map[new Point(tileX, tileY)]
+
+            // risk level is increased by tile distance from origin:
+            let tileDistance = (y / crow) + (x / ccol)
+
+            // risk level wraps around from 9 to 1:
+            let riskLevel = (tileRiskLevel + tileDistance - 1) % 9 + 1
+                select new KeyValuePair<Point, int>(new Point(x, y), riskLevel)
+            );
+
+            return res;
+        }
+
+        // store the points in a dictionary so that we can iterate over them and 
+        // to easily deal with points outside the area
+        Dictionary<Point, int> GetRiskLevelMap(string input)
+        {
+            var map = input.Split("\n");
+            return new Dictionary<Point, int>(
+                from y in Enumerable.Range(0, map[0].Length)
+                from x in Enumerable.Range(0, map.Length)
+                select new KeyValuePair<Point, int>(new Point(x, y), map[y][x] - '0')
+            );
+        }
+
+        IEnumerable<Point> Neighbours(Point point) =>
+            new[] {
+           point with {y = point.y + 1},
+           point with {y = point.y - 1},
+           point with {x = point.x + 1},
+           point with {x = point.x - 1},
+            };
+    }
+}
+record Point(int x, int y);