.

Author: EdCharlesDiesel

Algorithms/Medium_Algorithms.Tests/UnitTest1.cs

@@ -743,10 +743,42 @@ public static bool compare(List<string> arr1, string[] arr2)
                 }
             }
             return true;
-        } 
+        }
         #endregion
 
+        #region RiverSizesClass
+        [Fact]
+        public void RiverSizesClassTestCase1()
+        {
+            int[,] input = {
+              { 1, 0, 0, 1, 0 },
+              { 1, 0, 1, 0, 0 },
+              { 0, 0, 1, 0, 1 },
+              { 1, 0, 1, 0, 1 },
+              { 1, 0, 1, 1, 0 },
+            };
+            int[] expected = { 1, 2, 2, 2, 5 };
+            List<int> output = RiverSizesClass.RiverSizes(input);
+            output.Sort();
+            Assert.True(compare(output, expected));
+        }
 
+        public static bool compare(List<int> arr1, int[] arr2)
+        {
+            if (arr1.Count != arr2.Length)
+            {
+                return false;
+            }
+            for (int i = 0; i < arr1.Count; i++)
+            {
+                if (arr1[i] != arr2[i])
+                {
+                    return false;
+                }
+            }
+            return true;
+        } 
+        #endregion
 
 
 

Algorithms/Medium_Algorithms/MediumAlgorithmsClass.cs

@@ -1525,9 +1525,93 @@ public Node AddChild(string name)
                     return this;
                 }
             }
-        } 
+        }
         #endregion
 
+        #region RiverSizesClass
+        /// <summary>
+        /// 
+        /// </summary>
+        public class RiverSizesClass
+        {
+            public static List<int> RiverSizes(int[,] matrix)
+            {
+                List<int> sizes = new List<int>();
+                bool[,] visited = new bool[matrix.GetLength(0), matrix.GetLength(1)];
+                for (int i = 0; i < matrix.GetLength(0); i++)
+                {
+                    for (int j = 0; j < matrix.GetLength(1); j++)
+                    {
+                        if (visited[i, j])
+                        {
+                            continue;
+                        }
+                        traverseNode(i, j, matrix, visited, sizes);
+                    }
+                }
+                return sizes;
+            }
+
+            public static void traverseNode(int i, int j, int[,] matrix, bool[,] visited, List<int> sizes)
+            {
+                int currentRiverSize = 0;
+                List<int[]> nodesToExplore = new List<int[]>();
+                nodesToExplore.Add(new int[] { i, j });
+                while (nodesToExplore.Count != 0)
+                {
+                    int[] currentNode = nodesToExplore[nodesToExplore.Count - 1];
+                    nodesToExplore.RemoveAt(nodesToExplore.Count - 1);
+                    i = currentNode[0];
+                    j = currentNode[1];
+                    if (visited[i, j])
+                    {
+                        continue;
+                    }
+                    visited[i, j] = true;
+                    if (matrix[i, j] == 0)
+                    {
+                        continue;
+                    }
+                    currentRiverSize++;
+                    List<int[]> unvisitedNeighbors =
+                    getUnvisitedNeighbors(i, j, matrix, visited);
+                    foreach (int[] neighbor in unvisitedNeighbors)
+                    {
+                        nodesToExplore.Add(neighbor);
+                    }
+                }
+                if (currentRiverSize > 0)
+                {
+                    sizes.Add(currentRiverSize);
+                }
+            }
+
+            public static List<int[]> getUnvisitedNeighbors(int i, int j, int[,] matrix, bool[,] visited)
+            {
+                List<int[]> unvisitedNeighbors = new List<int[]>();
+                if (i > 0 && !visited[i - 1, j])
+                {
+                    unvisitedNeighbors.Add(new int[] {i - 1, j
+                    });
+                }
+
+                if (i < matrix.GetLength(0) - 1 && !visited[i + 1, j])
+                {
+                    unvisitedNeighbors.Add(new int[] { i + 1, j });
+                }
+                if (j > 0 && !visited[i, j - 1])
+                {
+                    unvisitedNeighbors.Add(new int[] { i, j - 1 });
+                }
+
+                if (j < matrix.GetLength(1) - 1 && !visited[i, j + 1])
+                {
+                    unvisitedNeighbors.Add(new int[] { i, j + 1 });
+                }
+                return unvisitedNeighbors;
+            }
+        } 
+        #endregion