Adv2018/D17.1/Program.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;

namespace D17._1
{
    class Program
    {
        enum EnumType
        {
            Clay, StillWater, RunningWater
        }

        static void Main(string[] args)
        {
            if (args.Length < 1) return;
            if (File.Exists(args[0]) == false) return;
            var file = File.OpenText(args[0]);

            var reg = new Regex(@"[xy]=(\d+), [xy]=(\d+)[.][.](\d+)");

            var map = new Dictionary<(int x, int y), EnumType>();
            var rwater = new Dictionary<(int x, int y), (int x, int y)>();

            int MAXY = 0;
            int MINX = int.MaxValue;
            int MINY = int.MaxValue;
            int MAXX = 0;

            do
            {
                var line = file.ReadLine();
                if (line == null) break;

                var result = reg.Match(line);

                CreateMap(map, ref MAXY, ref MINX, ref MINY, ref MAXX, line, result);

            } while (true);

            // Start with river
            rwater.Add((500, 0), (500, 0));
            map.Add((500, 0), EnumType.RunningWater);

            while (rwater.Count > 0)
            {
                //PrintMap(map, MINX, MAXX, MAXY);

                var enumer = rwater.FirstOrDefault();
                var water = enumer.Key;
                var source = enumer.Value;

                if (map.ContainsKey((water.x, water.y + 1)) == false && water.y + 1 > MAXY)
                {
                    rwater.Remove(water);
                    continue;
                }

                if (map.ContainsKey((water.x, water.y + 1)) == false || map[(water.x, water.y + 1)] == EnumType.RunningWater)
                {
                    RaindropsOnRoses(map, rwater, water);
                }

                else
                {
                    ExpandToBothSides(map, rwater, water, source);

                    int maxX, minX;
                    bool canConvert = CanConvertToStillWater(map, rwater, water, source, out maxX, out minX);

                    if (canConvert)
                        ConvertToStillWater(map, rwater, water, source, maxX, minX);
                    else
                        rwater.Remove(water);
                }
            }

            PrintMap(map, MINX, MAXX, MAXY);
            var countEx1 = map.Count(m => (m.Key.y >= MINY && m.Key.y <= MAXY) && (m.Value == EnumType.RunningWater || m.Value == EnumType.StillWater));
            var countEx2 = map.Count(m => (m.Key.y >= MINY && m.Key.y <= MAXY) && (m.Value == EnumType.StillWater));
            Console.WriteLine($"The answer is {countEx1} flooded tiles, {countEx2}m3 still water");
        }

        private static void RaindropsOnRoses(Dictionary<(int x, int y), EnumType> map, Dictionary<(int x, int y), (int x, int y)> rwater, (int x, int y) water)
        {
            rwater.Remove(water);
            rwater.TryAdd((water.x, water.y + 1), water);
            map.TryAdd((water.x, water.y + 1), EnumType.RunningWater);
        }

        private static void ConvertToStillWater(Dictionary<(int x, int y), EnumType> map, Dictionary<(int x, int y), (int x, int y)> rwater, (int x, int y) water, (int x, int y) source, int maxX, int minX)
        {
            for (var x = minX; x <= maxX; ++x)
            {
                var res = map.TryGetValue((x, water.y), out var type);
                if (type == EnumType.RunningWater)
                {
                    map[(x, water.y)] = EnumType.StillWater;
                    rwater.Remove((x, water.y));
                }
            }

            rwater.Remove(water);
            rwater.TryAdd(source, (source.x, source.y - 1));
        }

        private static bool CanConvertToStillWater(Dictionary<(int x, int y), EnumType> map, Dictionary<(int x, int y), (int x, int y)> rwater, (int x, int y) water, (int x, int y) source, out int maxX, out int minX)
        {
            bool canConvert = true;
            maxX = 0;
            minX = 0;
            for (int x = water.x; canConvert; ++x) // left to right
            {
                maxX = x;
                var res = map.TryGetValue((x, water.y), out var type);
                if (res == false)
                {
                    canConvert = false;
                    rwater.TryAdd((x - 1, water.y), source);
                }
                else if (type == EnumType.Clay) break;
            }
            for (int x = water.x; canConvert; --x) // right to left
            {
                minX = x;
                var res = map.TryGetValue((x, water.y), out var type);
                if (res == false)
                {
                    canConvert = false;
                    rwater.TryAdd((x + 1, water.y), source);
                }
                else if (type == EnumType.Clay) break;
            }

            return canConvert;
        }

        private static void ExpandToBothSides(Dictionary<(int x, int y), EnumType> map, Dictionary<(int x, int y), (int x, int y)> rwater, (int x, int y) water, (int x, int y) source)
        {
            var next = water;

            while (true)
            {
                var last = next;
                next = (last.x - 1, water.y);

                var res = map.TryGetValue((next.x, water.y), out var value);
                if (res && value == EnumType.Clay) break;

                rwater.Remove(last);
                rwater.TryAdd(next, source);
                map.TryAdd(next, EnumType.RunningWater);

                var hasBottom = map.TryGetValue((next.x, next.y + 1), out var bottom);
                if (hasBottom == false || bottom == EnumType.RunningWater)
                    break;
            }

            next = water;

            while (true)
            {
                var last = next;
                next = (last.x + 1, water.y);

                var res = map.TryGetValue((next.x, water.y), out var value);
                if (res && value == EnumType.Clay) break;

                rwater.Remove(last);
                rwater.TryAdd(next, source);
                map.TryAdd(next, EnumType.RunningWater);

                var hasBottom = map.TryGetValue((next.x, next.y + 1), out var bottom);
                if (hasBottom == false || bottom == EnumType.RunningWater)
                    break;
            }
        }

        private static void CreateMap(Dictionary<(int x, int y), EnumType> map, ref int MAXY, ref int MINX, ref int MINY, ref int MAXX, string line, Match result)
        {
            var c1 = int.Parse(result.Groups[1].Value);
            var rmin = int.Parse(result.Groups[2].Value);
            var rmax = int.Parse(result.Groups[3].Value);

            if (line.StartsWith("x"))
            {
                if (c1 > MAXX) MAXX = c1;
                if (c1 < MINX) MINX = c1;
            }
            else
            {
                if (c1 > MAXY) MAXY = c1;
                if (c1 < MINY) MINY = c1;
            }

            for (int i = rmin; i <= rmax; ++i)
            {
                if (line.StartsWith("x"))
                {
                    if (i > MAXY) MAXY = i;
                    if (i < MINY) MINY = i;

                    map.TryAdd((c1, i), EnumType.Clay);
                }
                else
                {
                    if (i > MAXX) MAXX = i;
                    if (i < MINX) MINX = i;
                    map.TryAdd((i, c1), EnumType.Clay);
                }
            }
        }

        private static void PrintMap(Dictionary<(int x, int y), EnumType> map, int MINX, int MAXX, int MAXY)
        {
            var std = Console.Out;
            var file = File.CreateText("out.txt");
            Console.SetOut(file);
            Console.SetCursorPosition(0, 0);
            for (int y = 0; y <= MAXY; ++y)
            {
                for (int x = MINX - 1; x <= MAXX + 1; ++x)
                {

                    var res = map.TryGetValue((x, y), out var type);
                    if (res == false) Console.Write(".");
                    else if (type == EnumType.Clay) Console.Write("#");
                    else if (type == EnumType.RunningWater) Console.Write("|");
                    else if (type == EnumType.StillWater) Console.Write("~");
                }
                Console.WriteLine();
            }
            Console.SetOut(std);
            file.Flush();
            file.Close();
        }
    }
}